Providing unique codes on packaging for liquid foods

Abstract

A unique code for marking liquid food packaging is generated with a header portion (40) containing unencrypted code definition data ([E], [G]) representing the code structure and / or code generation methodology, and a payload portion (41) containing encrypted payload data ([EP]). Encryption ensures that the code is sufficiently scrambled to make guessing and malicious code generation difficult. Prior to encryption, the payload data may be defined to be unique for each code, thereby also making the code unique. Prior to encryption, the payload data may be structured to allow efficient searching of the code in a database. When a code is read from a package, the code may be processed by extracting the code definition data ([E], [G]), identifying the payload portion (41), extracting the encrypted payload data ([EP]), regenerating the payload data by decryption, and searching for the code in a database based on the payload data or one or more subsets of the payload data. [Selection Diagram] Figure 4A

Description

[Technical field]

[0001] The present invention relates generally to the manufacture of packaging for liquid food products and, in particular, to the provision of cords to such packaging. [Background technology]

[0002] Every day, billions of liters of water, milk, juice and other liquid foods are consumed worldwide. Most liquid foods are distributed in paper-based packages, also called carton packages. These packages are manufactured to protect both the nutritional value and the taste of the liquid foods inside. Fundamental technologies make it much easier to package and distribute liquid foods around the world.

[0003] For example, it is well known to provide this and other types of packaging for liquid food products with a code indicating the expiration date or origin of the liquid food on each package. Such codes are often applied to the packaging in plain text so that they can be read and understood by the consumer.

[0004] To date, the most suitable and robust techniques for providing packaging with a code that uniquely identifies each individual package containing a liquid food product have not been widely adopted. Summary of the Invention [Problem to be solved by the invention]

[0005] SUMMARY OF THE PRESENT EMBODIMENT It is an object of the present invention to at least partially overcome one or more limitations of the prior art.

[0006] Another object is to provide a technique by which a globally unique code can be provided to a package.

[0007] A further object is to provide such a technique which reduces the risk of fraudulent generation of a valid code and / or thwarts efforts to guess a valid code based on another code or through the use of random mechanisms.

[0008] In addition to further objects that will emerge from the description below, one or more of these objects are achieved, at least in part, by a method for generating code, a computer readable medium, a code, a system, and a method for processing code according to the embodiments defined in the independent and dependent claims. [Means for solving the problem]

[0009] A first aspect of the invention is a method of generating a code for uniquely identifying a package for a liquid food product, the method comprising the steps of obtaining code defining data representative of at least one of a structure of the code and a methodology for generating the code, obtaining payload data that is unique to each package, operating a predefined encryption algorithm on the payload data to generate encrypted payload data, including the code defining data in a predefined header portion for the unencrypted data of the code for each package, and including the encrypted payload data in a predefined payload portion of the code for each package.

[0010] Furthermore, in some embodiments, operating the predefined encryption algorithm includes selecting an encryption key, and the method further includes including key identification data representative of the selected encryption key in the predefined header portion.

[0011] Further, in some embodiments, selecting an encryption key includes obtaining a random number and selecting an encryption key from among a predefined set of encryption keys based on the random number, and the key identification data represents the selected encryption key.

[0012] Additionally, in some embodiments, the key identification data further represents a version number of the predefined set of encryption keys.

[0013] Furthermore, in some embodiments, the selected encryption key is a private key.

[0014] Additionally, in some embodiments, the methodology represented by the code definition data includes a predefined encryption algorithm.

[0015] Additionally, in some embodiments, the method further includes operating a hash function on the encrypted payload data to generate hash data, and including the hash data as a readable sub-portion of the header portion.

[0016] Additionally, in some embodiments, the hash data is generated as a digital signature.

[0017] Additionally, in some embodiments, the method further includes obtaining location data representative of the geographic location and including the location data in the payload data so as to be common to all packages originating from a manufacturing unit in the geographic location.

[0018] Additionally, in some embodiments, the location data is indicative of at least one of a manufacturer, a factory, a manufacturing line, and a manufacturing facility.

[0019] Furthermore, in some embodiments, the method further comprises obtaining indexation data enabling grouping of consecutively generated codes, and including the indexation data in the payload data.

[0020] Additionally, in some embodiments, obtaining the indexation data includes obtaining a current value of at least one continuous counter configured to output a continuous value that is incremented or decremented over time.

[0021] Additionally, in some embodiments, indexation data is obtained to include a combination of current values ​​output by multiple continuous counters.

[0022] Additionally, in some embodiments, at least a portion of the indexation data is obtained to represent a current time.

[0023] Additionally, in some embodiments, the method further includes obtaining random data for each package and including the random data in the payload data.

[0024] Further, in some embodiments, obtaining the random data includes obtaining the random values ​​from a randomized counter that is operated to intermittently arrange values ​​belonging to a predefined range of mutually unique values ​​in a random order and to output at least a subset of the values ​​one by one in the random order.

[0025] Furthermore, in some embodiments, the method further includes obtaining a random value for each package from a randomization counter configured to generate random values ​​that belong to a predefined range and that are mutually unique within a predefined time that is the shortest unit of time relative to a current time, and including the random value in the payload data.

[0026] Further, in some embodiments, the code is generated in accordance with a batch production request, and the at least one continuous counter includes a batch counter, and the method further includes a step of incrementing or decrementing the batch counter for each batch production request, and the step of obtaining the indexation data further includes a step of obtaining a current value of the batch counter.

[0027] Further, in some embodiments, the at least one continuous counter includes a package counter, and the method further includes the step of incrementing or decrementing the package counter for each package, and the step of obtaining the indexation data further includes the step of obtaining a current value of the package counter.

[0028] Further, in some embodiments, the method is performed by a first code generator included in a group of identical code generators, the method further comprising the steps of obtaining redundant data that distinguishes the first code generator from other code generators in the group, and including the redundant data in at least one of the header portion and the payload data.

[0029] Additionally, in some embodiments, the encrypted payload data and the code definition data are included in the code as respective series of binary values.

[0030] Additionally, in some embodiments, the method further includes marking the package with a code.

[0031] Furthermore, in some embodiments, the marking step includes embedding a code in a data carrier on one of the packages for the liquid food product, on a sheet material from which a container portion of one of the packages is to be formed, or on an element to be joined with the container portion.

[0032] Furthermore, in some embodiments the marking step further comprises converting the code into a format suitable for embedding in a data carrier.

[0033] Additionally, in some embodiments, the marking step includes controlling a printer or an ablation device to mark the surface portion, or storing the code in an electronic tag for radio frequency identification.

[0034] Additionally, in some embodiments, the method further comprises storing the code in a database, and selecting the database and / or a section of the database for storage based on payload data of the code.

[0035] A second aspect of the present invention is a computer readable medium comprising computer instructions which, when executed by a processor, cause the processor to perform the method of the first aspect or any of the embodiments of the first aspect.

[0036] A third aspect of the invention is code generated by the method of the first aspect or any of the embodiments of the first aspect.

[0037] A fourth aspect of the present invention is a system comprising at least one device configured to carry out the method of the first aspect or any of the embodiments of the first aspect.

[0038] A fifth aspect of the invention is a method of processing a code generated by the method of the first aspect or any of the embodiments of the first aspect after reading the code from a package, the method comprising the steps of extracting code defining data from the code, identifying a payload portion based on the code defining data, extracting encrypted payload data from the code, operating a predefined decryption algorithm on the encrypted payload data to generate payload data, and looking up the code in a database based on the payload data, or one or more subsets of the payload data.

[0039] A sixth aspect of the present invention, which is applicable to all of the embodiments including hash data in the header portion described above, is a method of processing a code after it has been read from a package, the method including the steps of extracting hash data from the header portion of the code, extracting encrypted payload data from the payload portion of the code, operating a hash function on the encrypted payload data to generate current hash data, and rejecting the code if the current hash data differs from the hash data. Other objects, features, aspects and advantages of embodiments of the present invention will become apparent from the following detailed description, the accompanying claims and drawings. [Brief description of the drawings]

[0040] [Figure 1A-1B] FIG. 1A is a schematic diagram of a manufacturing and distribution chain for a package for a liquid food product, and FIG. 1B is a schematic diagram of such a package. [Diagram 2] FIG. 1 is a block diagram of an example system for marking packages with unique codes according to an embodiment of the present invention. [Diagram 3] 3 is a block diagram of a machine implementing one or more components of the system in FIG. 2. [Figure 4A-4B] FIG. 4A shows an example of the structure of a code generated by an embodiment of the present invention, and FIG. 4B shows an example of the structure of payload data and the use of the code to generate encrypted payload data. [Diagram 5] FIG. 2 is a block diagram of a structure for generating payload data according to an embodiment of the present invention. [Figure 6] Here is an example of an instance of code during code generation: [Figure 7A-7B] 4 illustrates example parameters that may be included in the payload data according to an embodiment of the present invention. [Figure 8] 4 is a flow chart of an example process for generating a unique code to mark a package according to an embodiment of the present invention. [Figure 9] 1 is a flow chart of an example method for processing code read from a package. [Figure 10A-10B] 4 illustrates an example of a database structure for storing codes generated by an embodiment of the present invention. [Figure 11] FIG. 3 is a block diagram of a variation of the system in FIG. 2. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0041] DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0023] Embodiments of the present invention will now be described more fully hereinafter with reference to the accompanying drawings, which illustrate some, but not all, embodiments of the present invention. Indeed, the present invention may be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will satisfy applicable legal requirements. Like numbers refer to exactly the same elements.

[0042] Further, it is understood that, to the extent possible, any of the advantages, features, functions, innovations, and / or operational aspects of any of the embodiments of the present invention described and / or contemplated herein can be included in any of the other embodiments of the present invention described and / or contemplated herein, and vice versa. Moreover, to the extent possible, any term that is in the singular is intended to include the plural, and vice versa, unless expressly stated otherwise. As used herein, "at least one" shall mean "one or more," and these phrases are intended to be interchangeable. Thus, the terms "a" and / or "an" shall mean "at least one" or "one or more," even if the phrases "one or more" or "at least one" are used herein. As used herein, unless the context otherwise requires to indicate the language or necessary meaning, the words "comprise" or variations such as "comprises" or "comprising" are used in an inclusive sense, i.e., to specify the presence of stated features and do not exclude the presence or addition of further features in various embodiments of the invention.

[0043] Well-known functions or configurations are not described in detail for the sake of brevity and / or clarity.Unless otherwise specified, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs.

[0044] 1A is a schematic diagram of a manufacturing and distribution chain for packages for liquid foods. A liquid food is any food that is non-solid or pourable at room temperature, including beverages such as fruit juice, wine, beer, soda, dairy products, sauces, oils, cream, custard, soup, and the like, and solid foods in liquids (e.g., beans, fruits, tomatoes, stews, etc.). The distribution chain shown includes a manufacturing stage 1 that produces ingredients for the packages, a filling stage 2 that produces packages containing the liquid food, a distribution stage 3 that distributes the packages containing the liquid food, a retail stage 4 that provides the packages to consumers, and a consumer stage 5 where the packages are handled by the consumer and the liquid food is consumed.

[0045] In production stage 1, sheet material for the packaging is produced in a converting plant 10. The sheet material is typically paper based and is supplied in rolls 11 to the filling stage 2. In the example shown, stage 1 further comprises a dedicated plant 12 which produces caps 13 (typically of a plastic material) for the packaging. In case the packaging is formed without caps, plant 12 is not present in stage 1. It is further conceivable that stage 1 includes additional plants which produce specific components for the packaging.

[0046] In filling stage 2, a filling plant 14 operates with sheet material 11, caps 13, and liquid food to provide packages containing the liquid food. For example, a production line at filling plant 14 may form containers with sheet material 11, fill the containers with the liquid food, seal the containers, and form packages. The production line may attach caps 13 to the containers. Figure 1B shows an example of a package 16 produced by filling plant 14. Stage 2 may further include external handling 15 of the packages, such as palletizing before entering distribution stage 3.

[0047] The manufacturing network may generally include many different conversion plants 10, capping plants 12, and filling plants 14 distributed globally. Each of the plants 10, 12, 14 may include multiple manufacturing lines.

[0048] The applicant has identified the need to mark each package containing a liquid food product with a unique code. Each code should therefore be unique within the entire ecosystem of plants 10, 12, 14 in a manufacturing network as illustrated in FIG. 1A, at least for a predefined lifespan. The code may be applied to the package at any of the plants 10, 12, 14 illustrated in FIG. 1A. For example, the code may be applied at a predefined location on the sheet material 11 by the conversion plant 10, to be placed on each package 16 produced by the filling plant 14. In another example, the code may be applied to each cap 13 by the capping plant 12. In a further example, the code may be applied to the sheet material 11, the cap 13, the intermediate container or the package 16 by the filling plant 14. It is intended that the package 16 may include multiple such unique codes (e.g., one on the cap 13 and one on the package 16). It is further conceivable that the unique code may be provided to the package, or to a group of packages, in subsequent handling 15 (e.g., palletizing).

[0049] The code is applied to the package 16 as embedded in a data carrier 17 shown in Figure 1B, which can be implemented by any known technique for providing a code to a manufactured product. In one example, the data carrier 17 is printed on the package 16, for example as a series of human readable symbols (e.g. characters) or machine readable graphical symbols such as one or more barcodes or two-dimensional codes (data matrix, Quick Response (QR) code, etc.). In another example, the data carrier is an electronic tag, and the code is stored and available for retrieval, for example by wireless communication with the tag (e.g. NFC, RFID, BLE, etc.) according to any conventional standard for this purpose.

[0050] Providing each package with a unique code enables many different applications, including tracking and tracing the package throughout the manufacturing and distribution chain (FIG. 1A), inspecting the authenticity of the package, linking to web content about the package for access by consumers or retail personnel, associating the code with promotional campaigns and lotteries, and triggering automation of machinery used in steps 1-5 (FIG. 1A) (e.g., any equipment in the filling plant 14, cooling systems in transport vehicles, warehouse trucks, robots, refrigerators, etc.).

[0051] What all such applications have in common is that each generated code is not only marked on the package, but is also stored in a database, optionally in association with additional data. During the execution of the application, the database is accessed to search for a particular code. Search speed proves to be a key aspect in the implementation of the application. This is a challenging task considering the large number of codes that are generated, given the enormous number of packages containing liquid foods that are produced each year. For example, over 188 billion Tetra Pak® packages were sold in 2016.

[0052] Applicants have identified the following desirable features of a unique code for a package: 1) A very large number (typically 10 12 This allows for unique codes (more than one). 2) Allows for small data carriers that fit into the smallest packaging sizes manufactured within the ecosystem. 3) Minimize the risk of generating malicious code. 4) Minimize the risk of guessing valid codes. 5) Allows for fast rejection of false codes. 6) Allows efficient and fast searching of codes in a database. 7) Allows for scalable code structures and code lengths. 8) Enables the robustness and maintenance characteristics necessary to ensure continuous and efficient large-scale production operations worldwide.

[0053] One possible technique for generating codes is to generate each code as a number in sequential order, but such a code cannot achieve at least features 3) and 4).

[0054] Another possible technique for generating codes is to generate each code as a random or pseudorandom number with a length such that the number of unique codes can significantly exceed the number of packages to be marked. Such codes can achieve features 3) and 4), but are difficult to combine with features 5) and 6).

[0055] An embodiment of the invention to be illustrated below is based on the insight that all of the features 1) to 8) are possible by generating a code comprising a header portion and a payload portion (wherein the data in the payload portion is encrypted and where the data in the header portion is not encrypted). The encryption ensures that the code is sufficiently scrambled to make guessing and unauthorized code generation difficult. Furthermore, the data in the payload portion may be defined to be unique for each code before encryption, thereby making the code unique as well. Furthermore, the data in the payload portion may be structured before encryption to allow efficient search of the code in a database. Furthermore, the header portion may further include information enabling scalability in code structure and code length, information enabling fast denial, information enabling decryption of the payload portion, etc.

[0056] Additionally, the payload portion may be generated to represent characteristics of the manufacturing unit that applied the code to the package before encryption. For example, the payload portion may indicate at least one of the geographic location of the manufacturing unit (plant, manufacturing line, manufacturing facility, etc.) and a timestamp for each package. This is a user-transparent, robust way of ensuring that the payload portion is unique within the ecosystem.

[0057] An example of an embodiment of a system 20 configured for code generation and marking of packages is shown diagrammatically in FIG. 2. The system 20 includes a control unit 21, a code generator 22, and a marking device 23. The control unit 21 is configured to obtain a code (CODE) from the code generator 22 and generate a control signal (CTRL) that causes an article of manufacture (e.g., sheet material 11, cap 13, or package 16) to provide the code to the marking device 23. As can be seen from the above, the marking device 23 may be a printer, an ablation device, or a device that embeds a code in an electronic tag that can be attached to the article of manufacture by the marking device 23 or that can be pre-attached to the article of manufacture. In the illustrated example, the control unit 21 has or is connected to an input interface 24 that may include a man-machine interface (MMI) through which an operator can manually enter input data and / or control the operation of the system. Alternatively, or in addition, the input interface 24 may include a receiver that receives input data or control data from an external controller over a wired or wireless connection.

[0058] The control unit 21 is operative to generate a request (REQ) for one or more codes from a code generator 22, which generates one or more codes on demand and supplies the codes to the control unit 21. The control unit 21 or the code generator 22 (shown in FIG. 2) may be further configured to enter each code into a database 26, optionally in association with additional data. It is further contemplated that such additional data may be added to the database 26 remote from the system 20.

[0059] The system 20 in FIG. 2 may be implemented for in-line generation of codes or for offline (batch) generation of codes. In such an in-line embodiment, codes are generated in real time during production in the plants 10, 12, 14, and the code generator 22 is typically located in the plants 10, 12, 14. The code generator 22 may be configured to return a single unique code for each input request REQ from the control unit 21. As used herein, "request" refers to any type of signal that can cause the code generator to generate a code. In an offline embodiment, the control unit 21 sends a request REQ to the code generator for a batch of codes before production. Depending on the implementation, the request may include an identifier of the production unit (plant, production line, production facility, etc.) and the number of codes to be generated. In response to the request, the code generator 22 generates and returns a batch of unique codes. In an offline embodiment, the code generator may be (but is not necessarily) located away from the production unit, for example, in a networked server system that can be configured to generate and transmit codes over a communication network to different plants in the ecosystem.

[0060] Applicants currently contemplate implementing an in-line embodiment in the filling plant 14 and an off-line embodiment in the conversion plant 10 and capping plant 12 .

[0061] 3 is a diagram of a machine 30 that may represent the code generator 22. The machine 30 includes a communication module 31 that defines one or more interfaces for data communication according to any suitable protocol or protocols. The machine 30 further includes one or more processors 32, such as a central processing unit (CPU), a graphics processing unit (GPU), a digital signal processor (DSP), one or more application specific integrated circuits (ASICs), a field programmable gate array (FPGA), or any combination thereof. The machine 30 further includes a system memory 33 that may include computer memory in the form of volatile and / or non-volatile memory, such as read only memory (ROM), random access memory (RAM), and flash memory. The memory 33 may store computer instructions 34 (e.g., software or program code) that cause the machine 30 to perform any one of the methodologies described herein. The instructions 34 may be provided to the machine 30 on a computer readable medium 35, which may be a tangible (non-persistent) product (e.g., magnetic medium, optical medium, read-only memory, flash memory, digital tape, etc.) or a propagated signal. The instructions 34 may be protected by restrictions and limited access using known methods. When executed by a processor, the instructions 34 may cause the processor 32 to perform any one of the methodologies described herein. It is understood that the control unit 21 may also be implemented by the corresponding machine 30, albeit with different computer instructions. It is further conceivable that the control unit 21 and the code generator 22 are implemented together on the machine 30.

[0062] It is contemplated that code generator 22 may be implemented via cloud computing, where the functions of code generator 22 are performed by resources on any number of collaborative computer systems or servers. In such an implementation, the collaborative computer systems together correspond to machine 30 in FIG.

[0063] FIG. 4A shows an embodiment of the structure of the code generated by the invention. The code includes a header portion 40 and a payload portion 41. The payload portion 41 holds the encrypted payload data [EP]. The header portion 40 is readable in the sense that it is not encrypted and therefore the contents of the header portion 40 can be accessed without the need for an encryption key. However, it is conceivable to obfuscate the header portion 40 or parts of the header portion 40. The term "obfuscation" (also sometimes indicated as "obfuscating" or "clouding") refers to a process applied to a data set that intentionally makes it difficult to access the data set if the algorithm applied by the process is unknown. On the other hand, the term "encryption" refers to a process applied to a data set that requires a secret (e.g. a key) to be able to access the data set in a reasonable time, even if the algorithm applied by the process is known.

[0064] In the example of Fig. 4A, the header portion 40 includes five sub-portions holding the encoding data [E], the generator data [G], the random key selector [R], the key version [K] and the hash data [H] respectively. The encoding data [E] is code-defining data and has a fixed and predefined position and range in the entire code. Thus, the value of the encoding data [E] indicates the structure and length of the code, with different values ​​indicating different structures and / or lengths. The structure may include the range of the header and payload portions 40, 41, and the type, position and range of the sub-portions contained in the header portion 40. The provision of the encoding data [E] makes the code scalable in structure and length. The scalability is advantageous in that the structure and length of the code can be adapted to match the encoding capabilities of a particular data carrier or to eventual future unforeseen uses and applications. In a currently preferred embodiment, the encoding data [E] further indicates the location in the manufacturing chain for the plant that is marking the package with the code, for example to distinguish between the conversion plant 10, the capping plant 12 and the filling plant 14. Furthermore, the generator data [G] is code definition data and indicates how the code was generated, i.e. the procedure and steps followed. For example, if the code is generated by an in-line or offline embodiment, the value of the generator data [G] may indicate the encryption algorithm (cipher) used, etc. The provision of the generator data [G] increases the versatility of the code generation process. The random key selector [R] specifies the encryption key used to encrypt the payload data. The provision of the random key selector [R] allows a random selection to be made among a predefined set of encryption keys when generating the code. This increases security by allowing the use of different encryption keys between codes, and also introduces variability into the header portion 40, making the code and the code generation process even more difficult to decipher. The key version [K] specifies the version of the predefined set of encryption keys used in the code generation process. The provision of key versions [K] allows a predefined set of cryptographic keys to be updated for increased security in a forward and backward compatible manner.The hash data [H] is or includes a hash value of the encrypted payload in the payload portion 41. The provision of the hash data [H] allows for fast rejection of false codes, thereby reducing the need to look up the code in a database, even if fast rejection falsely authorizes a certain amount of false codes. The use of hash data [H], which is directly readable from the header portion 40, allows for fast rejection without decryption of the encrypted payload [EP]. In one embodiment, the hash data [H] is or includes a digital signature. The provision of the digital signature allows for authentication of the code, thereby allowing fast rejection of false codes with high accuracy.

[0065] It should be noted that both [R] and [K] must be known to identify the encryption key that was used to generate a particular code. Thus, [R] and [K] together form "key identification data." However, it should be noted that codes can instead be generated without [R], in which case only a single encryption key is used, and / or without [K], in which case only a single version of a key or keys is used.

[0066] Although not shown in Figure 4A, the header portion 40 may contain additional data (e.g., a hyperlink). It should further be noted that neither the header portion 40 nor the payload portion 41 need be contiguous portions of the code as shown. Instead, the header portion 40 may be split into subsets that are interleaved with or of the payload portion 41. However, it is presently believed that the structure in Figure 4A optimizes both the code generation and the processing of the code that is read from the package.

[0067] In the example below, the code is generated as a series of binary values ​​(bits). In a currently preferred embodiment, which is not limited to the present invention, the code consists of 80 bits, with the header portion 40 containing 16 bits and the payload portion 41 containing 64 bits. In this non-limiting example, [E] is 2 bits, [G] is 1 bit, [R] is 2 bits (i.e., 4 different encryption keys in a predefined set), [K] is 2 bits (i.e., up to 4 different versions of a predefined set), and [H] is 8 bits.

[0068] 4B illustrates in a schematic manner the steps of operating an encryption algorithm F on payload data [P] to generate encrypted payload data [EP] for inclusion in the payload portion 41 of the code. Any conceivable encryption algorithm F may be used, including any symmetric encryption algorithm that uses a secret encryption key for both encryption and decryption, and any asymmetric algorithm that utilizes a pair of public and private encryption keys. In one non-limiting embodiment, the encryption algorithm is a block cipher such as Blowfish, DES, IDEA, RC5 or AES. Encryption scrambles the payload data, obliterating its structure. In general, encryption helps to protect the data contained in the payload portion 41, making it difficult to deduce a valid code based on another code and minimizing the risk of unauthorized generation.

[0069] Furthermore, FIG. 4B illustrates various types of parameters that can be included in the payload data [P]. In the illustrated example, the payload data [P] includes location data [A] that represents a geographic location, typically the geographic location of the manufacturing unit that applies the code to the package. It should be noted that the location data [A] can represent a geographic location indirectly, for example, by indicating a particular manufacturer, plant, manufacturing line, or manufacturing facility with a known geographic location. In FIG. 4B, the payload data [P] further includes indexation data [B] that allows grouping of consecutively generated codes. As will be further illustrated later, the location data [A] and / or the indexation data [B] can help to speed up searching for codes in a database. In FIG. 4B, the payload data [P] further includes random data [C] that introduces unpredictable variability into the payload data [P]. This unpredictable variability makes the code even more difficult to analyze and imitate, thus reducing the risk of generating fraudulent code.

[0070] In general, in industrial environments, and especially in mass production, outages cause costly production losses and should be avoided. It is therefore desirable to duplicate production equipment to allow so-called hot swapping, i.e. to be able to switch from the main equipment to the spare equipment essentially without stopping production. This also applies to the code generators in FIG. 2. FIG. 11 illustrates a variant of the system in FIG. 2 with two code generators 22, 22A. Although not shown in FIG. 11, as in FIG. 2, the control unit 21 is connected to a marking device 23. The code generators 22, 22A are structurally and functionally identical, meaning that they use exactly the same methodology to generate codes with the same structure and length. The code generator 22 is used as the main generator and the code generator 22A is the spare generator (indicated by the dashed arrow). The controller 28 is connected to the code generators 22, 22A and controls the switching from one code generator to the other by means of a switch control signal (SWC). When switching from one code generator to the other, it may be difficult to synchronize the two code generators 22, 22A with sufficient accuracy to avoid the same code being generated by both code generators 22, 22A in connection with the switching. To overcome this problem, the payload data [P] further includes redundant data [D] as shown in FIG. 4B. The redundant data [D] represents the particular code generator that is generating the code. Thus, the code generators 22, 22A are configured to input different redundant data [D] into the code. As a result, the codes generated by the code generators 22, 22A are inherently different and hot swapping can be performed without the risk of generating duplicate codes. For example, hot swapping may be performed in case of a malfunction of the primary code generator 22 or for scheduled maintenance of the primary code generator 22. In addition to allowing hot swapping, the provision of redundant data [D] allows two or more code generators to operate in parallel and supply code to the control unit 21.

[0071] In a variant, instead or in addition, redundant data [D] is included in the header portion 40 .

[0072] As a further annotation to FIG. 4B, note that the payload data [P] includes an empty box indicating that the payload data [P] may include additional data.

[0073] FIG. 5 shows an example of a structure for generating payload data [P], for example in a code generator (22 in FIG. 2). At the heart of this structure is a payload generator 50, which receives or obtains current data values ​​from a set of data providers (51-57) and combines these data values ​​into a structured payload data [P], for example as shown in FIG. 4B. The data provider 51 provides the above-mentioned position data [A]. In the above-mentioned inline embodiment, the position data [A] may be predefined and stored in a memory. Thus, the data provider 51 may be a memory (see 33 in FIG. 3). In the above-mentioned offline embodiment, at least a part of the position data [A] may be included in the batch request REQ received by the code generator 23, and the data provider 51 may be configured to retrieve the position data [A] from the batch request. In FIG. 5, the continuity counters 52-55 count the respective parts [B] of the indexation data [B]. 1 ~[B] 4 As used herein, a "sequential counter" refers to a counter that outputs values ​​in a predictable order. Specifically, each of the sequential counters 52-55 in FIG. 5 is operated to generate an output value that is incremented or decremented over time from a start value to an end value. As used herein, "increment" means increase (by any step) and "decrement" means decrease (by any step). In a non-limiting example, the sequential counters 52-55 output values ​​that are incremented or decremented by one. Each counter 52-55 may be operated with a predefined modulo such that the output value flips from the end value to the start value. The output value from the sequential counters 52-55 (e.g., [B]=[B]) may be calculated by forming indexation data [B]. 1 [B]2 [B] 3 [B] 4 ) in combination. The provision of the output value of at least one sequential counter in the code allows for grouping of sequential codes, which allows for grouped storage of the codes in database 26 (FIG. 2), which makes the database easier to search. Each counter 52-55 may represent a physical quantity related to a manufacturing process in a manufacturing unit that applies the codes to packages. In one example, one or more of counters 52-55 may represent a time parameter for manufacturing, such that indexation data [B] includes a timestamp for each package. Such a grouping of time counters may work together to represent a current time in different time units (e.g. one or more of years, months, weeks, days, hours, minutes, seconds).

[0074] In another example, one of the counters 52-55 may be a package counter that outputs the number of packages marked in a production unit. The package counter typically increments or decrements the package counter output value from a starting value without applying a predefined modulo. In an in-line embodiment, the package counter output value may be incremented for each package marked (e.g. for each input REQ to the code generator in FIG. 2). In a particular variant, the package counter is adjusted with a time counter such that it is reset to the starting value whenever the value of the time counter changes. Preferably, the time counter represents the shortest time unit among the available time counters. If the shortest time unit is one second, the package counter output value is reset every second, giving a resolution of less than one second. In an offline embodiment, the package counter output value may be incremented or decremented for each code generated in a batch of codes. Further examples of counters are described below with reference to FIGS. 7A and 7B.

[0075] As can be seen from the above, the continuity counters 52-55 may be incremented or decremented synchronously with the code generation process or independently of the code generation process. Examples of synchronization operations include the above-mentioned modification of the package counter for each package that is marked or each code that is generated, while the above-mentioned time counter may be automatically started to update its output value to represent the current time.

[0076] In the example of FIG. 5, the randomizing counter 56 provides random data [C]. The randomizing counter 56 is operable to output random values ​​within a predefined range and is preferably operated to change the output value of the randomizing counter in synchronism with the code generation process. In one embodiment, the randomizing counter 56 is configured to provide random values ​​without overlap within a predefined time, i.e. the random values ​​are mutually unique within a predefined time. In one implementation, the randomizing counter 56 may arrange all values ​​belonging to a predefined range of mutually unique values ​​in a random order and output the values ​​or a subset of values ​​one by one in the random order. In a particular variant, the randomizing counter 56 is adjusted with the time counter so that it is reset (i.e. rearranges the values ​​in a random order) whenever the value of the time counter changes. Preferably, the time counter represents the shortest time unit among the available time counters. If the shortest time unit is one second, the output value of the randomizing counter 56 thereby provides a resolution of one second or less. It will be appreciated that such a randomizing counter 56 can replace the above-mentioned package counter having a resolution of one second or less in an in-line embodiment.

[0077] The data provider 57 in Fig. 5 provides the above-mentioned redundancy data [D], which may be predefined and stored in a memory. Thus, the data provider 57 may be a memory (see 33 in Fig. 3).

[0078] The counters 52 to 56 may be implemented by dedicated hardware, dedicated software, or a combination of these. When the code generator is implemented by a computer, the time counters may be implemented by existing support functions on the computer, for example, support functions included in the operating system.

[0079] FIG. 7A shows example parameters / data fields in the payload data [P] in an in-line embodiment, for example when generating a code in the filling plant 14 in FIG. 1. In the illustrated example, the location data [A] includes a manufacturer ID, a plant ID, a line ID, and an equipment ID. The manufacturer ID identifies the manufacturer operating the filling plant 14. The plant ID identifies the filling plant 14, the line ID identifies the production line, and the equipment ID identifies the equipment that applies the code to the package (e.g., a filler, a cartoner, or a palletizer). In the illustrated example, the code is designed to handle 4095 different manufacturers, 255 different plants for each manufacturer, 63 lines within each plant, and 8 different equipment. In the illustrated example, the indexation data [B] represents the current time and includes the year, day, hour, minute, and second (wherein the year is given by the current year modulo 8). The values ​​in the respective data fields are generated by respective time counters as described with reference to FIG. 5. Additionally, the payload data [P] includes a package counter providing sub-second resolution, as will be described with reference to Figure 5. The package counter value may be included in the indexation data [B] if generated by a continuous counter (see counters 52-55 in Figure 5), or in the random data [C] if generated by a randomized counter (see counter 56 in Figure 5).

[0080] FIG. 7B shows examples of parameters / data fields in the payload data [P] in an offline embodiment, for example when the codes are generated in batches on demand by the conversion plant 10 or the capping plant 12. In the illustrated example, the location data [A] includes a manufacturing unit ID that identifies the plant. In the illustrated example, part of the indexation data [B] represents the current time and includes the year and month. The values ​​of these parameters may be generated by respective time counters, as described with reference to FIG. 5. Furthermore, the payload data [P] includes a request number and a package counter, which may also be the indexation data [B] generated by respective sequential counters. For example, the request number may be incremented or decremented for each batch request received from a particular plant (i.e., a given value of the manufacturing unit ID) in the current year and current month. To provide the request number, the structure in FIG. 5 appears to include one sequential batch counter for each plant. Whenever the month counter reverses to a starting count from the starting value of the month counter, the sequential batch counter is reset to the starting value of the sequential batch counter (e.g., 0). Similarly, the package counter may be incremented or decremented for each code generated for each value of the requisition number, i.e. for a particular batch. To provide the package counters, the structure in FIG. 5 is seen to include a sequential package counter for each batch counter. Whenever the value of the associated batch counter changes, the sequential package counter is reset to the starting value of the sequential package counter (e.g., 0). Alternatively, as shown in FIG. 7B, at least one of the requisition number and the package counter may be random data [C]. The structure for generating the random values ​​of the requisition number and / or package counter may be identical to the structure for generating the sequential values ​​of the requisition number and / or package counter, as described above, except for replacing each sequential counter with a randomized counter. The randomized counter for the requisition number may be configured to be reset with each change in the month value, and the randomized counter for the package counter may be configured to be reset with each change in the requisition number value.

[0081] In the example of Figure 7B, the code is designed to handle 1000 different plants, over 500,000 batch requests per month, and over 134 million packages per request. In Figure 7B, the payload data [P] further includes redundant data [D] in the form of a master generator server that can be set to 0 or 1.

[0082] Figure 8 is a flow chart of a process carried out in the system of Figure 2. The process includes one part of generating a code, corresponding to previous steps 801-803 and subsequent steps 804-813 which are repeated for each code to be generated. Steps 801-813 are carried out by the code generator 22 in the system of Figure 2. Furthermore, the process includes another part of applying a code to a package, corresponding to steps 814-816 which are carried out together by the control unit 21 and the marking device 23 (a printer in this example). Furthermore, the process includes a step 817 of storing the code in a database, which step 817 may be carried out by the control unit 21 or the code generator 22.

[0083] Consider the previous steps in more detail. Step 801 obtains a value for the encoding data [E] corresponding to the structure and length of the code to be generated. Step 802 obtains a value for the generator data [G] corresponding to the procedure and steps to be followed when generating the code. Step 803 obtains a value for the key version [K] corresponding to the current version of the encryption key to be used to encrypt the payload data [P]. These values ​​of [E], [G] and [K] are entered into all codes generated during the current execution of the process. Step 804 includes the values ​​of [E], [G] and [K] in the header portion 40 of the code. Figure 6 illustrates the instances 61 to 66 of the code during the execution of the process in Figure 8, where a full portion / sub-portion means that this portion contains a value. It can be seen that step 804 corresponds to instances 61, 62 and 63 in Figure 6.

[0084] Then steps 805-807 are performed to select an encryption key. Step 805 preferably obtains a random number from a random number generator configured to generate cryptographically secure random numbers. Step 806 then selects an encryption key among a predefined set of encryption keys based on the random number, for example by using a lookup table or function that provides an association between the random number and the encryption key. Step 806 provides the predefined set of encryption keys by key version [K]. Step 807 sets a random key selector [R] to represent the selected encryption key and includes [R] in header portion 40 (instance 64 in FIG. 6). For example, the encryption keys in each version of the predefined set of encryption keys may be designated by a respective number, and step 807 may set the encryption key selector [R] to this number.

[0085] Step 808 obtains payload data [P] and may be performed by the payload generator 50 in FIG. 5. In the illustrated example, step 808 includes a first sub-step 808A of obtaining position data [A], a first sub-step 808B of obtaining indexation data [B], and a third sub-step 808C of obtaining random data [C]. As illustrated, sub-step 808B may include an operation 808B1 of obtaining a current value of one or more continuity counters (see 52-55 in FIG. 5), and sub-step 808C may include an operation 808C1 of obtaining a current value of one or more randomization counters (see 56 in FIG. 5). Although not shown in FIG. 8, step 808 may obtain redundant data [D]. However, it should be noted that at least [C] and [D] are optional in order to form a unique code in the ecosystem. Step 808 further comprises forming payload data [P] by arranging [A]-[D] according to the current code structure, to the extent that [A]-[D] have been obtained. The process then proceeds to step 809, which operates an encryption function (F in FIG. 4B) on the payload data [P] to generate encrypted payload data [EP]. Step 810 includes [EP] in the payload portion 41 of the code (instance 65 in FIG. 6). Step 811 operates a hash function on [EP] to generate hash data [H]. Any conceivable hash function may be used, for example a non-cryptographic hashing function such as Pearson hashing. Step 812 includes [H] in the header portion 40 (instance 66 in FIG. 6). Once the code is completed and step 813 outputs the code, the process returns to step 804 to generate another unique code.

[0086] Step 814 operates on each code output by step 813 to perform a transcoding of the code. As mentioned above, a code is composed of a series of bit values. Transcoding involves converting the code into a format suitable for encoding on a data carrier. In the example of encoding a series of bit values ​​into a two-dimensional code, it is known to transcode these bit values ​​into alphanumeric characters. As an example, instance 67 in FIG. 6 shows diagrammatically a series of alphanumeric characters C0-C15 resulting from transcoding. Transcoding is well known in the art of marking objects and will not be described in more detail. Step 815 generates a data carrier in the form of a two-dimensional code representing the alphanumeric characters C0-C15, and step 816 prints this data carrier on a sheet material, a cap or a package.

[0087] Fig. 9 is a flow chart of a method for processing a code that has been read from a package marked with a code, for example by the process in Fig. 8, according to an embodiment of the invention. Devices for reading different types of data carriers are well known in the art and will not be described further. Depending on the implementation, the readout will be the code as originally generated, for example a bit string, or transcoded data, for example a string of alphanumeric characters that is later transcoded back to the underlying original code.

[0088] In the method of FIG. 9, step 901 inputs the code that has been read from the package. Step 902 reads the encoded data [E] from this code. As mentioned above, the encoded data [E] has a fixed and predefined position in the whole code. Based on the value of [E], the position of all relevant parts and subparts in the code is known to the method. Then, step 903 may read the generator data [G] that determines the syntax of the code and any functions used in generating the code. Then, the method performs a fast rejection check of the code by steps 904 to 907. Step 904 reads the hash data [H], step 905 reads the encrypted payload data [EP], step 906 calculates the hash of [EP] by using a predefined hash function that is fixed for the whole code or that can be identified based on [G], and step 907 compares the calculated hash with [H]. If step 907 finds a mismatch, the method proceeds to step 908, which ends the method. As a result, the code is rejected. Otherwise, the method proceeds to step 909, which reads the random key selector [R] and the key version [K] from the code. Based on this, step 910 obtains the corresponding encryption key, whereupon step 911 decrypts [EP] by using the encryption key and a predefined encryption algorithm that is fixed for the whole code or can be identified based on [G]. As a result, step 911 regenerates the payload data [P], and step 912 reads at least one of the position data [A] and the indexation data [B], or specific data fields in [A] and / or [B] (see Figures 7A and 7B) from the payload data [P]. Depending on the value or values ​​obtained, step 913 can access a database and search for the code in the database. Step 914 then outputs the search result, for example a confirmation that the code has been found, a message that the code has not been found, any information related to the code in the database, etc.

[0089] A few non-limiting examples of how location data [A] and / or indexation data [B] can be accessed to improve database management, and database searching is now provided with reference to Figures 10A and 10B. Figure 10A shows an example of a database 26 partitioned (shown by dotted lines) into a first partition (top) that stores codes generated in an offline embodiment, and a second partition (bottom) that stores codes generated in an inline embodiment. The first partition is sub-partitioned (shown by dotted lines) by plant as given by location data [A] (see manufacturing unit ID in Figure 7B). In Figure 10A, each such sub-partition contains a stack of cylinders, each cylinder representing a batch of codes generated for a respective batch request. Within each sub-partition, the batches are searchable by indexation data [B]. For example, considering the indexation data [B] in Figure 7B, the codes in each batch contain the same combination of year, month and request number.

[0090] The second division is sub-divided (shown by dotted lines) by manufacturer and plant as given by location data [A] (see Manufacturer ID and Plant ID in FIG. 7A). FIG. 10A illustrates a sub-division for Manufacturer 2, Plant 1, which is further divided by production line as given by location data [A] (see Line ID in FIG. 7A). Each such sub-division contains a stack of cylinders, each cylinder representing a group of codes generated for a particular combination of year and date of manufacture (see year and date in FIG. 7A). Thus, within each further division, the groups are searchable by indexation data [B].

[0091] Returning to Figure 8, it can be seen that when transmitting the code for storage in a database 26, step 817 preferably also transmits values ​​of the [A] and / or [B] parameters associated with the storage of the code in the particular database 26.

[0092] Based on FIG. 10A, a practitioner can see that by providing location data [A] and / or indexation data [B], the database can be configured with variable levels of partitioning precision suited to the particular database constraints (which can vary depending on the implementation and provider).

[0093] In the example of Figure 10B, the databases 26 in Figure 10A are separated into one database 26A storing codes for packages manufactured in Europe and one database 26B storing codes for packages manufactured in North America. The separation into Europe and North America is given by the geographic location of the respective plants.

[0094] Thus, as shown in Figure 10B, the provision of location data [A] allows for distributed storage, which can further speed up searches by reducing data transmission times. Furthermore, data storage volume per location can be reduced, with cost and performance benefits. Furthermore, it provides additional benefits in situations where data storage needs to be geographically localized to comply with national regulations / laws.

Claims

A method for generating a code for uniquely identifying a package (16) for liquid food, comprising: obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) on the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header portion (40) for the non-encrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each of the packages (16); including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40); characterized in that: the step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number; further comprising obtaining indexing data ([B]) enabling grouping of consecutively generated codes and including the indexing data ([B]) in the payload data ([P]); the step of obtaining the indexing data ([B]) includes obtaining the current value of at least one continuous counter (52-55) configured to output a continuous value that increases or decreases over time; A method. Claim 2 A method for generating a code for uniquely identifying a package (16) for liquid food, comprising: obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) on the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header part (40) for the unencrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload part (41) of the code for each of the packages (16); including key identification data ([R], [K]) representing the selected encryption key in the predefined header part (40); comprising the step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number; further comprising obtaining indexation data ([B]) enabling grouping of a group of consecutively generated codes and including the indexation data ([B]) in the payload data ([P]); further comprising obtaining random data ([C]) for each package (16) and including the random data ([C]) in the payload data ([P]); the step of obtaining the random data ([C]) includes obtaining random values from a randomization counter (56) that is operated to intermittently arrange values belonging to a predefined range of mutually unique values in a random order and output at least a subset of the values one by one in the random order; a method

3. A method for generating a code for uniquely identifying a package (16) for liquid food, comprising: obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) with the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header part (40) for the unencrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload part (41) of the code for each of the packages (16); including a step of including key identification data ([R], [K]) representing the selected encryption key in the pre-defined header part (40); comprising; the step of selecting the encryption key includes a step of obtaining a random number and a step of selecting the encryption key from a pre-defined set of encryption keys based on the random number; further including a step of obtaining indexing data ([B]) enabling grouping of consecutive generated codes and a step of including the indexing data ([B]) in the payload data ([P]); obtaining at least a part of the indexing data ([B]) to represent the current time; obtaining a random value ([C]) for each package (16) from a randomization counter (56) configured to generate random values that belong to a pre-defined range and are unique to each other within a pre-defined time that is the shortest time unit for the current time, and including the random value ([C]) in the payload data ([P]); A method.

4. A method for generating a code for uniquely identifying a package (16) for liquid food, including a step of obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a pre-defined encryption algorithm (F) with the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a pre-defined header part (40) for the non-encrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a pre-defined payload part (41) of the code for each package (16); including key identification data ([R], [K]) representing the selected encryption key in the pre-defined header part (40); comprising; the step of selecting the encryption key includes a step of obtaining a random number and a step of selecting the encryption key from a pre-defined set of encryption keys based on the random number; A step of obtaining indexing data ([B]) that enables grouping of consecutive generation codes, and further includes a step of including the indexing data ([B]) in the payload data ([P]), The step of obtaining the indexing data ([B]) includes a step of obtaining the current value of at least one continuous counter (52 to 55) configured to output a continuous value that increases or decreases over time, The code is generated according to a batch generation request, the at least one continuous counter (52 to 55) includes a batch counter, the method further includes a step of increasing or decreasing the batch counter for each batch generation request, and the step of obtaining the indexing data ([B]) further includes a step of obtaining the current value of the batch counter, Method.

5. A method for generating a code for uniquely identifying a package (16) for liquid food, A step of obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code, A step of obtaining payload data ([P]) unique to each package (16), Operating a predefined encryption algorithm (F) with the payload data ([P]) to select an encryption key, and generating encrypted payload data ([EP]) using the selected encryption key, Including the code definition data ([E], [G]) in a predefined header portion (40) for the non-encrypted data of the code for each package (16), Including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each package (16), Including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40), Comprising, The step of selecting the encryption key includes a step of obtaining a random number and a step of selecting the encryption key from a predefined set of encryption keys based on the random number, A step of obtaining indexing data ([B]) that enables grouping of consecutive generation codes, and further includes a step of including the indexing data ([B]) in the payload data ([P]), The step of obtaining the indexing data ([B]) includes a step of obtaining the current value of at least one continuous counter (52 to 55) configured to output a continuous value that increases or decreases with time. The at least one continuous counter (52 to 55) includes a package counter, and the method further includes a step of increasing or decreasing the package counter for each package (16), and the step of obtaining the indexing data ([B]) further includes a step of obtaining the current value of the package counter. Method.

6. A method for generating a code for uniquely identifying a package (16) for liquid food, obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) with the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header portion (40) for the non-encrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each package (16); including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40); comprising The step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number. executed by a first code generator (22) included in a group of the same code generators (22, 22A), and obtaining redundant data ([D]) for distinguishing the first code generator from other code generators in the group, and further including the step of including the redundant data ([D]) in at least one of the header portion (40) and the payload data ([P]). Method.

7. A method for generating a code for uniquely identifying a package (16) for liquid food, comprising: obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) with the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header portion (40) for the non-encrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each of the packages (16); including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40); characterized in that the step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number; further comprising the step of marking the package (16) with the code; the step of marking includes embedding the code in a data carrier (17) on one of the package (16) on a sheet material (11) in which one container portion of the package (16) is to be formed or on an element (13) to be coupled to the container portion; a method. **Claim 8** A method for generating a code for uniquely identifying a package (16) for liquid food, comprising: obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) with the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header portion (40) for the unencrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each of the packages (16); including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40); comprising the step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number; further including the step of marking the code on the package (16); the marking step includes controlling a printer or an ablation device (23) to mark a surface portion, or storing the code in an electronic tag (17) for wireless identification; a method.

9. A method for generating a code for uniquely identifying a package (16) for liquid food, obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) with the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header portion (40) for the unencrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each of the packages (16); including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40); comprising the step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number; Further comprising the step of storing the code in a database (26; 26A, 26B), and selecting the database (26; 26A, 26B) and / or a section of the database (26; 26A, 26B) for storage based on the payload data ([P]) of the code. Method.

10. The method according to any one of claims 1 to 9, wherein the key identification data ([R], [K]) further represents a version number of the predefined set of encryption keys.

11. The method according to any one of claims 1 to 9, wherein the selected encryption key is a private key.

12. The method according to any one of claims 1 to 9, wherein the methodology represented by the code definition data ([E], [G]) includes the predefined encryption algorithm (F).

13. The method according to any one of claims 1 to 9, further comprising the steps of operating a hash function on the encrypted payload data ([EP]) to generate hash data ([H]), and including the hash data ([H]) as a readable subpart of the header part (40).

14. The method according to claim 13, wherein the hash data ([H]) is generated as a digital signature.

15. The method according to any one of claims 1 to 9, further comprising the steps of obtaining location data ([A]) representing a geographical location, and including the location data ([A]) in the payload data ([P]) so as to be common to all packages originating from a manufacturing unit at the geographical location.

16. The method according to claim 15, wherein the location data ([A]) indicates at least one of a manufacturer, a factory, a production line, and production equipment.

17. The method according to any one of claims 1 to 9, further comprising the steps of obtaining indexing data ([B]) enabling grouping of a group of continuously generated codes, and including the indexing data ([B]) in the payload data ([P]).

18. The method according to claim 17, wherein at least a part of the indexing data ([B]) is obtained to represent the current time.

19. The method according to claim 17 or 18, further comprising the step of obtaining random data ([C]) for each package (16), and the step of including the random data ([C]) in the payload data ([P]).

20. The method according to any one of claims 1 to 9, wherein the encrypted payload data ([EP]) and the code definition data ([E], [G]) are included in the code as respective series of binary values.

21. The method according to claim 7 or 8, wherein the step of marking further comprises the step of converting the code into a format suitable for embedding in the data carrier (17).

22. A computer-readable recording medium (35) storing software or program code that causes a processor (32) to execute a method for generating a code that uniquely identifies a package (16) for liquid food when executed by the processor (32), the method comprising: obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; obtaining payload data ([P]) unique to each package (16); operating a predefined encryption algorithm (F) on the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; including the code definition data ([E], [G]) in a predefined header portion (40) for the unencrypted data of the code for each package (16); including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each package (16); including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40); comprising: The step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number. A computer-readable recording medium (35). A system (20) comprising at least one device (21, 22) configured to execute a method for generating a code for uniquely identifying a package (16) for liquid food, said method comprising: Obtaining code definition data ([E], [G]) representing at least one of the structure of the code and the methodology for generating the code; Obtaining payload data ([P]) unique to each package (16); Operating a predefined encryption algorithm (F) on the payload data ([P]) to select an encryption key and generating encrypted payload data ([EP]) using the selected encryption key; Including the code definition data ([E], [G]) in a predefined header portion (40) for the non-encrypted data of the code for each package (16); Including the encrypted payload data ([EP]) in a predefined payload portion (41) of the code for each respective package (16); Including key identification data ([R], [K]) representing the selected encryption key in the predefined header portion (40); Comprising: The step of selecting the encryption key includes obtaining a random number and selecting the encryption key from a predefined set of encryption keys based on the random number. System (20).

24. A method of processing the code generated by the method according to any one of claims 1 to 9 after reading the code from a package, comprising: Extracting the code definition data ([E], [G]) from the code; Identifying the payload portion (41) based on the code definition data ([E], [G]); Extracting the encrypted payload data ([EP]) from the code; Extracting the key identification data ([R], [K]) from the code; Obtaining an encryption key from a predefined set of encryption keys based on the key identification data ([R], [K]); Operating a predefined decryption algorithm on the encrypted payload data ([EP]) to generate the payload data ([P]) using the encryption key. Searching for the code in a database (26; 26A, 26B) based on the payload data ([P]), or one or more subsets ([A], [B]) of the payload data ([P]); A method comprising.

Images