Patent Description:
Connected devices of a variety of types are becoming increasingly common in modern homes, factories and many other environments. While networks of connected devices offer many benefits and improvements over conventional environments, such environments present new network security challenges. One such challenge is presented when adding new devices to an already secured network, as such devices generally need to be authenticated to prevent malicious devices from joining the network. While in some instances network devices can be preconfigured with security credentials that can be used to authenticate the devices, many devices are not preconfigured in this way. As such, a technical problem exists in how to securely authenticate these devices before adding them to the network.

<CIT> discloses a method of generating an identifier from a semiconductor device including volatile memory having a plurality of memory cells. <CIT> discloses a data receiving device and a key generating device configured to verify whether transmitted data is not falsified and whether the data is transmitted along a right path.

In one aspect, a method includes retrieving, on a first device, an indexable data structure storing a plurality of unique values in a random or pseudorandom order. The method further includes dividing a unique identifier into a first ordered plurality of index values, wherein the unique identifier is associated with the first device. Additionally, the method includes retrieving a first ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the first ordered plurality of index values as an index, where the indexable data structure stores a plurality of unique values in a random or pseudorandom order. The method also includes generating a second ordered plurality of index values by processing each of the index values in the first ordered plurality of index values using a predefined transformation operation. The method further includes retrieving a second ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the second ordered plurality of index values as an index. The method includes combining the first ordered plurality of values and the second ordered plurality of values into a security key. The method additionally includes using the security key in processing one or more data communication messages between the first device and a remote computing device to authenticate the first device.

According to an embodiment, the method further includes procedurally generating a sequential indexable data structure; and performing a randomization operation on the sequential indexable data structure to generate the indexable data structure storing the plurality of unique values in the random or pseudorandom order.

According to an embodiment, the predefined transformation operation further includes one of a two's complement operation and a bitwise operation.

According to an embodiment, the bitwise operation includes one of an AND operation, an OR operation, a XOR operation, a NOT operation and a shift operation.

According to an embodiment, the unique identifier includes a Zigbee Effective User Identifier (EUID) wherein the unique identifier includes an <NUM>-byte value, and wherein the security key includes a <NUM>-byte value.

According to an embodiment, combining the first ordered plurality of values and the second ordered plurality of values includes concatenating the second ordered plurality of values onto an end of the first ordered plurality of values.

According to an embodiment, using the security key in processing one or more data communication messages between the first device and the remote computing device further includes: joining a first data communications network using the security key, while the first device is in an unauthenticated state; performing an asymmetric key exchange between the first device and the remote computing device, to authenticate the first device, wherein the first device is in an authenticated state upon successful completion of the asymmetric key exchange between the first device and the remote computing device.

In another aspect, a non-transitory computer-readable medium containing computer program code, when executed by operation of one or more computer processors, performs an operation. The operation includes: dividing a unique identifier into an ordered plurality of portions, wherein the unique identifier is associated with a first device; retrieving a plurality of values from an indexable data structure by accessing the indexable data structure using each of the plurality of portions as an index, where the indexable data structure stores a plurality of unique values in a random or pseudorandom order; processing the retrieved plurality of values into a security key; using the security key in processing one or more data communication messages between the first device and a remote computing device to authenticate the first device.

According to an embodiment, the operation further includes: procedurally generating a sequential indexable data structure; and performing a randomization operation on the sequential indexable data structure to generate the indexable data structure storing the plurality of unique values in the random or pseudorandom order.

According to an embodiment, the unique identifier includes a Zigbee Effective User Identifier (EUID).

According to an embodiment, the unique identifier includes an <NUM>-byte value, and wherein the security key includes an <NUM>-byte value.

According to an embodiment, processing the retrieved plurality of values to generate a security key further includes: generating a second ordered plurality of portions by processing each of the portions in the ordered plurality of portions using a predefined transformation operation; retrieving a second plurality of values from the indexable data structure by accessing the indexable data structure using each of the second ordered plurality of portions as an index; and combining the plurality of values and the second plurality of values to generate the security key, wherein combining the plurality of values and the second plurality of values includes concatenating the second plurality of values onto an end of the first plurality of values.

In another aspect, a system includes one or more computer processors and a non-transitory computer-readable memory containing computer program code that, when executed by operation of one or more computer processors, performs an operation including: dividing a unique identifier into a first ordered plurality of portions, wherein the unique identifier is associated with a first device; retrieving a first ordered plurality of values from an indexable data structure by accessing the indexable data structure using each of the first ordered plurality of portions as an index, where the indexable data structure stores a plurality of unique values in a random or pseudorandom order; generating a second ordered plurality of portions by processing each of the first ordered plurality of portions using a predefined transformation operation; retrieving a second ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the second ordered plurality of portions as an index; combining the first ordered plurality of values and the second ordered plurality of values to generate a security key; and using the security key in processing one or more data communication messages between the first device and a remote computing device to authenticate the first device.

According to an embodiment, the system further includes: procedurally generating a sequential indexable data structure; and performing a randomization operation on the sequential indexable data structure to generate the indexable data structure storing the plurality of unique values in the random or pseudorandom order.

According to an embodiment, the predefined processing algorithm further includes a two's complement operation.

When adding a new device to a secure network, a number of security determinations are made to ensure the new device does not compromise the security of the network. For example, a Dynamic Host Configuration Protocol (DHCP) server could be configured to assign Internet Protocol (IP) addresses only to authenticated devices on the network. Doing so can prevent untrusted and potentially malicious devices from joining the network.

However, a technical challenge exists in how to authenticate and more generally how to trust a new device added to a network. While some computing devices have ample resources to store numerous predefined device identifiers and execute sophisticated, resource-intensive techniques for authenticating themselves, other devices are much more limited in their computing resources that may be insufficient to implement such resource-heavy techniques. Moreover, while some such techniques may require that a device be preconfigured with a unique identifier during manufacturing (e.g., stored on a secure Read-Only Memory (ROM) of the device at the factory during manufacturing), many other devices (especially Brownfield devices) are not manufactured with such preconfigured information and/or secure memories. As such, lightweight techniques for surely authenticating a device on a network are needed.

One embodiment described herein includes retrieving, on a first device, an indexable data structure storing a plurality of unique values in a random or pseudorandom order. A unique identifier associated with the first device is divided into a first ordered plurality of index values. Embodiments retrieve a first ordered plurality of values from an indexable data structure by accessing the indexable data structure using each of the first ordered plurality of index values as an index. In a particular embodiment, the indexable data structure stores a plurality of unique values in a random or pseudorandom order. A second ordered plurality of index values is generated by processing each of the index values in the first ordered plurality of index values using a predefined transformation operation. Embodiments retrieve a second ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the second ordered plurality of index values as an index and combine the first ordered plurality of values and the second ordered plurality of values into a security key. The security key can then be used in processing one or more data communication messages between the first device and a remote computing device.

<FIG> is a block diagram illustrating a system configured with a device authentication component, according to one embodiment described herein. As shown, the system <NUM> includes a device management system <NUM> and a device <NUM>, interconnected via a network <NUM>. The device management system <NUM> includes a processor <NUM>, a memory, one or more input devices <NUM>, one or more output devices <NUM> and a network interface controller <NUM>. The memory includes a device management component <NUM>.

Generally, the device management component <NUM> is configured to authenticate, configure and otherwise manage devices (including device <NUM>) within the system <NUM>. For example, the device management component <NUM> could be configured to facilitate the assignment of an Internet Protocol (IP) address to the device <NUM> on the network <NUM>, upon authenticating the device <NUM> and determining that the device <NUM> is a trusted device.

The device <NUM> includes a processor <NUM>, a memory <NUM>, a network interface controller <NUM> and a communications interface <NUM>. The memory <NUM> contains program logic <NUM>, a device authentication component <NUM>, a device unique identifier <NUM>, and a random or pseudorandom array <NUM>. Generally, the program logic <NUM> represents any application-specific program logic that resides on the device <NUM> and generally relates to the overall purpose of the device <NUM>. For example, a particular automation device <NUM> within an industrial automation environment may have program logic <NUM> that relates to the function of the automation device within the industrial automation system. As another example, an energy management device <NUM> within a residential environment may be configured with program logic <NUM> configured to report on energy management metrics, to send notifications when a circuit breaker within the device <NUM> has tripped, or more generally any other functions that may be appropriate in a residential energy management context. Of course, such examples are for illustrative purposes only, and more generally any program logic <NUM> can be used for any of a variety of different environments and contexts, consistent with the functionality described herein.

Additionally, the device management system <NUM> is communicatively coupled to a data store <NUM>. In the depicted embodiment, the data store <NUM> includes device identifiers <NUM> and a random/pseudorandom array <NUM>. Generally, the device identifiers <NUM> represent unique identifiers of trusted devices within the system <NUM>. The random/pseudorandom array <NUM> generally corresponds to the random/pseudorandom array <NUM> in the memory <NUM> of the device <NUM>.

In one embodiment, the device authentication component <NUM> on the device can retrieve the random/pseudorandom array <NUM>. The random/pseudorandom array <NUM> comprises an indexable data structure storing a plurality of unique values in a random or pseudorandom order. The device authentication component <NUM> can divide the device unique identifier <NUM> into a first ordered plurality of index values. The device unique identifier <NUM> represents a data value that uniquely identifies the device <NUM> within a particular environment. For example, a device manufacturer that products multiple devices of various types can assign each device an identifier that uniquely identifies the respective device within the environment of all the manufacturer's ecosystem of devices.

The device authentication component <NUM> can retrieve a first ordered plurality of values from the random/pseudorandom array <NUM> by accessing the random/pseudorandom array <NUM> using each of the first ordered plurality of index values as an index. For example, the device authentication component <NUM> could divide the device unique identifier <NUM> into fixed-length portions (e.g., <NUM> bytes each) and could use each fixed-length portion as an index into the random/pseudorandom array <NUM>.

In one embodiment, the device authentication component <NUM> is configured generate a second ordered plurality of index values by processing each of the index values in the first ordered plurality of index values using a predefined transformation operation. For example, the device authentication component <NUM> could apply a two's complement transformation operation on each of the index values within the first ordered plurality of index values, and the resulting values could be stored in the second ordered plurality of index values. In doing so, the device authentication component <NUM> could maintain the same ordering of the values, such that the first value in the second ordered plurality of index values corresponds to the transformed first value in the first ordered plurality of index values, the second value in the second ordered plurality of index values corresponds to the transformed second value in the first ordered plurality of index values, and so on.

The device authentication component <NUM> could then retrieve a second ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the second ordered plurality of index values as an index. For example, the device authentication component <NUM> could concatenate the values retrieved from the random/pseudorandom array <NUM> (e.g., when using the fixed-length portions as an index). The device authentication component <NUM> could combine the first ordered plurality of values and the second ordered plurality of values into a security key.

Upon forming the security key, the device authentication component <NUM> could use the security key in processing one or more data communication messages between the first device and a remote computing device. For example, the device authentication component <NUM> could provide the device unique identifier <NUM> and the generated security key to the device management component <NUM> on the device management system <NUM>. Upon receiving the security key, the device management component <NUM> could generate a second security key using the aforementioned methodology using the received device unique identifier and the random/pseudorandom array <NUM> stored in the data store <NUM>. The device management component <NUM> could compare the received security key and the second security key and upon determining that the two keys are identical, the device management component <NUM> could consider the device <NUM> as authenticated as a trusted device.

In one embodiment, the device management component <NUM> can determine that the device <NUM> is a limited trusted device. In such an embodiment, the device management component <NUM> may not give full access to the device <NUM> but may assign or facilitate the assignment of an IP address to the device <NUM> on the network <NUM>. Once the device <NUM> is assigned a valid IP address, the device authentication component <NUM> on the device <NUM> could perform a second authentication process (e.g., with a remote server executing in a cloud computing environment) to fully authenticate the device <NUM>. Upon successful completion of the second authentication process and the communication of such successful completion to the device management component <NUM>, the device management component <NUM> may designate the device <NUM> a fully trusted device on the network <NUM> and may allow the device <NUM> to perform all operations within the system <NUM> corresponding to a trusted device. Of course, such an example is for illustrative purposes only, and one of ordinary skill in the art will recognize that the operations allowed by a trusted device can vary across different computing environments and installations.

<FIG> is a diagram illustrating a technique for generating a random or pseudorandom array, according to one embodiment described herein. As shown, the diagram <NUM> illustrates the generation of a random/pseudorandom array. In one embodiment, using an ordered array from <NUM> to <NUM>, a software component (e.g., device management component <NUM>) could shift the values in index to generate a random or pseudorandom array composed of unique values from <NUM> to <NUM>, with each value in the range appearing only once in the array. For example, the software component could shift the entire array in a given direction a particular number of indices, allowing values to wrap around to the opposite end of the array as needed. As another example, the software component could select a plurality of pairs of indices (e.g., using a random number generator to generate two values between <NUM> and <NUM>, ensuring that the same value is not selected twice) and could swap the values corresponding to these indices. The selection and swapping operations could be repeated a number of times until the array is determined to be sufficiently random or pseudorandom. Such a number could be a predefined number that is determined to produce a sufficiently random or pseudorandom array.

In an alternate embodiment, the software component could use a random number to generate a value between <NUM> and <NUM> for each index within the array, and the software component could discard any duplicate values (i.e., any values already inserted into the array). For example, a product manufacturer computing system could generate such an array and could deploy the resulting random/pseudorandom array on the device <NUM> at the time of manufacturer (e.g., the random/pseudorandom array <NUM> in memory <NUM>). Such an array can additionally be deployed to the device management system <NUM> (e.g., the random/pseudorandom array <NUM> in the data store <NUM>).

<FIG> are diagrams illustrating methods for generating a security key using a random or pseudorandom array, according to embodiments described herein. As shown in <FIG>, the diagram <NUM> illustrates a device unique identifier <NUM> for a device seeking to be authenticated on a network having an exemplary value of 0x1A2B3C4D5E6F. While in the depicted embodiment the device unique identifier <NUM> is a <NUM>-byte value, such an example is provided for illustrative purposes only and one of ordinary skill in the art will quickly recognize that numerous formats and lengths for device identifiers can be used, consistent with the functionality described herein. More generally, any value that is specific to the device seeking to be authenticated within an environment or device ecosystem can be used as the device unique identifier, consistent with the functionality described herein.

Moreover, in other embodiments, a non-device identifier value can be used as the starting point for the techniques described herein. For example, a device management system determining whether to authenticate a new device on a network could provide a value to the new device and the new device could send back a transformed value using the techniques described herein, at which point the device management system can determine whether to authenticate the new device (e.g., by also generating a transformed value using the same techniques and a separate copy of the random/pseudorandom array, comparing the two transformed values and authenticating the new device upon determining that the two transformed values match).

Returning to the depicted embodiment, the device authentication component <NUM> for the device can divide the device unique identifier <NUM> into byte portions and can use each of the byte portions as an index <NUM>(A)-(N) into an array of random/pseudorandom values <NUM> to retrieve the values <NUM>(A)-(N). The values <NUM>(A)-(N) can then be concatenated together following the same ordering as the indices were organized in when part of the UID <NUM>. For example, in the depicted embodiment, the device authentication component <NUM> could order the values starting with the value for Index 1A, followed by the value for Index 2B, followed by the value for Index 3C, and so on, and by concatenating the values together in this manner, could form a new value representing a security key.

The device authentication component <NUM> could then use the resulting security key in a variety of ways. For example, the device authentication component <NUM> could use the security key to perform an asymmetric key exchange with a device management component <NUM> on the local network to authenticate the device on which the device authentication component <NUM> is executing. For example, the device authentication component <NUM> could encrypt the security key using a public key corresponding to the device management component <NUM> (e.g., a public key provided by the device management component <NUM> and which the device management component <NUM> can access a corresponding private key for). The device authentication component <NUM> could then transmit the encrypted security key to the device management component <NUM> over the local network. The device authentication component <NUM> could also provide the UID <NUM> to the device management component <NUM> by transmitting the device unique identifier over the local network.

Upon receiving the encrypted security key and UID, the device management component <NUM> could repeat the process depicted in diagram <NUM> on the received UID. For example, the device management component <NUM> could divide the received UID into fixed-length portions and could use each individual portion as an index to access values within a random/pseudorandom array <NUM> stored in the data store <NUM>. The device management component <NUM> could then combine the resulting values preserving the ordering of the fixed-length portions in order to generate a new value.

The device management component <NUM> could then decrypt the received encrypted security key (e.g., using an existing private key corresponding to the public key used by the device authentication component <NUM> to encrypt the security key) and could compare the decrypted security key with the generated new value. If the device management component <NUM> determines the two values match, the device management component <NUM> could determine that the device on which the device authentication component <NUM> is executing is properly authenticated for purposes of network access on the local network.

In one embodiment, the device authentication component <NUM> is configured to only partially authenticate the device upon the compared keys matching. In such an embodiment, the device management component <NUM> could allow authenticated devices to access an external network (e.g., the Internet) for a limited period (e.g., a fixed period of time), upon authenticating the devices. For example, the device management component <NUM> could assign an IP address (e.g., via DHCP) to the authenticated device and could allow traffic from the authenticated device to access the external network for a predetermined period of time. The device authentication component <NUM> on the authenticated device could then access an external server (e.g., within a cloud computing environment) to perform a full authentication process with the external server. If such a full authentication process is successful, the external server could communicate this success to the device management component <NUM> and the device could be allowed full access on the network (e.g., the access level that is appropriate for a trusted device within the application-specific context). Of course, one of ordinary skill in the art will recognize that a number of different authentication algorithms and processes could be used by the external server to fully authenticate the device, and more generally any suitable authentication technique could be used consistent with the functionality described herein.

<FIG> illustrates an alternate embodiment in which the device authentication component <NUM> is configured to generate a security value from a UID by iterating through the fixed-length portions of the UID and using these fixed-length portions as indices multiple times. As shown, the device authentication component <NUM> in the diagram <NUM> has divided the UID into fixed-length portions of <NUM> byte each, resulting in the values 1A, 2B, 3C, 4D, 5E and 6F. Of course, such an example is provided for illustrative purposes only and one of ordinary skill in the art will recognize that portions of various lengths could be used, consistent with the functionality described herein.

The device authentication component <NUM> then iterates through a plurality of accesses to the array of random/pseudorandom values <NUM> using the fixed-length portions of the UID. In the depicted example, in a first iteration the device authentication component <NUM> uses the fixed-length portions as indices to access the array <NUM>, shown as index operations <NUM>(A)-(N). Additionally, in a second iteration, the device authentication component <NUM> accesses the array <NUM> by first processing the fixed-length portions of the UID using a predetermined function, and then uses the resulting value as an index into the array, shown as index operations <NUM>(A)-(N) where function F() is used to process the fixed-length portions. For example, the predetermined function F() could be a two's complement operation, a bitwise negation operation, or more generally any suitable predefined function that is capable of generating a value from another value in a deterministic manner could be used, consistent with the functionality described herein.

<FIG> is a flow diagram illustrating a method for generating a security key using a random or pseudorandom array, according to one embodiment described herein. As shown, the method <NUM> begins at block <NUM>, where the device authentication component <NUM> divides a unique identifier into an ordered plurality of portions, where the unique identifier is associated with a first device. The device authentication component <NUM> retrieves a plurality of values from an indexable data structure by accessing the indexable data structure using each of the plurality of portions as an index (block <NUM>). In one embodiment, the indexable data structure stores a plurality of unique values in a random or pseudorandom order.

The device authentication component <NUM> combines the retrieved plurality of values into a security key (block <NUM>). Additionally, the device authentication component <NUM> uses the security key in processing one or more data communication messages between the first device and a remote computing device (block <NUM>), and the method <NUM> ends.

<FIG> is a flow diagram illustrating a method for generating a security key using a random or pseudorandom array, according to one embodiment described herein. As shown, the method <NUM> begins at block <NUM>, where the device authentication component <NUM> retrieves, on a first device, an indexable data structure storing a plurality of unique values in a random or pseudorandom order. The device authentication component <NUM> divides a unique identifier into a first ordered plurality of index values, where the unique identifier is associated with a first device (block <NUM>). The device authentication component <NUM> retrieves a first ordered plurality of values from an indexable data structure by accessing the indexable data structure using each of the first ordered plurality of index values as an index (block <NUM>).

Additionally, the device authentication component <NUM> generates a second ordered plurality of index values by processing each of the index values in the first ordered plurality of index values using a predefined transformation operation (block <NUM>). The device authentication component <NUM> then retrieves a second ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the second ordered plurality of index values as an index (block <NUM>). Upon retrieving the second ordered plurality of values, the device authentication component <NUM> combines the first ordered plurality of values and the second ordered plurality of values into a security key (block <NUM>). The device authentication component <NUM> uses the security key in processing one or more data communication messages between the first device and a remote computing device (block <NUM>), and the method ends. For example, the device authentication component <NUM> could transmit the security key to a device management system <NUM> to obtain a valid IP address on a computing network. Once on the network, the device authentication component <NUM> could perform an authentication operation with a remote server to fully authenticate the device on the network. Once fully authenticated, the device may be given all permissions associated with a trusted device on the computing network.

In the preceding, reference is made to various embodiments. However, the scope of the present disclosure is not limited to the specific described embodiments. Instead, any combination of the described features and elements, whether related to different embodiments or not, is contemplated to implement and practice contemplated embodiments. Furthermore, although embodiments may achieve advantages over other possible solutions or over the prior art, whether or not a particular advantage is achieved by a given embodiment is not limiting of the scope of the present disclosure. Thus, the preceding aspects, features, embodiments and advantages are merely illustrative and are not considered elements or limitations of the appended claims except where explicitly recited in a claim(s).

The various embodiments disclosed herein may be implemented as a system, method or computer program product. Accordingly, aspects may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a "circuit," "module" or "system. " Furthermore, aspects may take the form of a computer program product embodied in one or more computer-readable medium(s) having computer-readable program code embodied thereon.

Any combination of one or more computer-readable medium(s) may be utilized. The computer-readable medium may be a non-transitory computer-readable medium. A non-transitory computer-readable medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the non-transitory computer-readable medium can include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. Program code embodied on a computer-readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for carrying out operations for aspects of the present disclosure may be written in any combination of one or more programming languages. Moreover, such computer program code can execute using a single computer system or by multiple computer systems communicating with one another (e.g., using a local area network (LAN), wide area network (WAN), the Internet, etc.). While various features in the preceding are described with reference to flowchart illustrations and/or block diagrams, a person of ordinary skill in the art will understand that each block of the flowchart illustrations and/or block diagrams, as well as combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer logic (e.g., computer program instructions, hardware logic, a combination of the two, etc.). Generally, computer program instructions may be provided to a processor(s) of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus. Moreover, the execution of such computer program instructions using the processor(s) produces a machine that can carry out a function(s) or act(s) specified in the flowchart and/or block diagram block or blocks.

The flowchart and block diagrams in the Figures illustrate the architecture, functionality and/or operation of possible implementations of various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s).

Claim 1:
A method (<NUM>), comprising:
retrieving (<NUM>), on a first device (<NUM>), an indexable data structure storing a plurality of unique values in a random or pseudorandom order;
dividing (<NUM>) a unique identifier (<NUM>) into a first ordered plurality of index values, wherein the unique identifier (<NUM>) is associated with the first device (<NUM>);
retrieving (<NUM>) a first ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the first ordered plurality of index values as an index;
generating (<NUM>) a second ordered plurality of index values by processing each of the index values in the first ordered plurality of index values using a predefined transformation operation;
retrieving (<NUM>) a second ordered plurality of values from the indexable data structure by accessing the indexable data structure using each of the second ordered plurality of index values as an index;
combining (<NUM>) the first ordered plurality of values and the second ordered plurality of values into a security key; and
using (<NUM>) the security key in processing one or more data communication messages between the first device (<NUM>) and a remote computing device to authenticate the first device (<NUM>).