Patent ID: 12204629

DETAILED DESCRIPTION

In the following description, certain specific details are set forth in order to provide a thorough understanding of various disclosed embodiments. However, one skilled in the relevant art will recognize that embodiments may be practiced without one or more of these specific details, or with other methods, components, materials, etc. Also in these instances, well-known structures may be omitted or shown and described in reduced detail to avoid unnecessarily obscuring descriptions of the embodiments.

The embodiments disclosed in certain embodiments provides a means of entering short sensitive information on a computing device in a secure way even when the device itself may be a vulnerable device, such as ATM, Server Key pads, personal computing devices, keyless doors, etc. The device would otherwise be considered insecure because it may have a keystroke logger, or the environment may be insecure because someone can steal sensitive information by shoulder surfing and seeing what the user is typing. The disclosed embodiments mitigate such risks associated with these threats and provide such protection with improved ease of use.

The above-mentioned problems can be solved by a combination of approaches and can be best explained with basic building blocks and components as further detailed below. In a number of embodiments, improvements over the art become apparent including the ability to use a single piece of information such as a pattern instead of both a password value itself and the pattern where just the pattern can be sent from a client device to a server. In some embodiments herein, the user can just remember the pattern rather than both a password and pattern. In some embodiments, there is no password to begin with or the password can be extracted by the system since a selected pattern can be based on pre-negotiated rules. In some embodiments, the pattern is dynamic and not static where the user is allowed to interact with a pattern or matrix such as by rotating a circular grid in one particular direction or another, pausing on segments, moving among layers or tiers, and performing other rules-based tasks that have significance in terms of decoding the user's dynamic data entry based on pre-negotiated rules. Only a server can generally extract the actual underlying data in such scenarios whereas the client cannot and certainly a casual observer such as a shoulder suffer cannot.

Component Diagram

The system100ofFIG.1illustrates a simple and an exemplary embodiments that includes a client edge device102that is a computing device that user110uses to access online resources on a server112(or elsewhere), and to enter sensitive data. The client edge device102can be a computer, laptop, or mobile phone, for example. The client edge device102can include an application104such as a widget App that runs on the edge device. The user110can interact with this App104to enter sensitive information. Examples of the widget app can be an online application in a local web browser, a client application on the edge device, or an app on the mobile phone.

The system100can further include the server112, which can be a server computer in the cloud, or a remote computer that processes the sensitive data submitted by the user using a data processing application114.

The server112and the client edge device102can have a data exchange via connection through a network link108. Data flows through this network link108using one or more protocols and usually a range of protocols. It is generally encrypted, but may not always be.

Data processing application114at the server112is an application that receives data sent by the widget app104, and processes it. It will determine next steps in the data exchange. For example, if data entered is a login credential or an apparent attempt at same (password, one time password (OTP), etc.), the data processing application114will allow login or reject it. In case the data entered is not a credential but a critical part of an online transaction, (e.g. bank transfer), the data processing application114will pass that information to downstream applications (not shown).

A primary focus of the embodiments are the algorithms and workings of the widget app104and data processing application114and the corresponding data exchange and encoding and decoding that occurs in a data exchange pipeline or connection (108). The exchange can be done in many different ways, but three main approaches are further detailed herein including a first approach designated as “Known Pattern/Typed”, a second designated as “Known Pattern, entered graphically”, and a third designated as “Known value, entered graphically”. There may be a number of variation on each of these themes.

Approach 1: Known Pattern, Typed

In this approach, the user110has selected a pattern and the user110then enters or types the corresponding matching characters by following a graphic pattern and rules known to both the client application104and data processing application114at the server.FIGS.2A,2B,3A,3B,4A, and4Billustrate such a scheme.

FIG.2Ademonstrates a user interface200as a simple single layer widget in the form of a circle or pie with multiple selectable slices. It is called single layer because there is only one circle and the pattern for entering data is simple as further illustrated byFIG.2Bwhere the user110would activate slices from point A to point B in a clockwise direction to enter the digits7024. The entry of the data can take the form of a swipe in the noted pattern, or clicking on each segment in the noted pattern or alternatively the sequential entry on an associated keyboard with the underlying numbers shown in each of the slices.

FIG.3Ashows a more complex user interface300and corresponding widget having two layered or tiered circles. Here, the pattern is selected by the user110using, for example, the following steps:

In the example shown inFIG.3B, the user selects a start position on the widget (point A) and further decides to first go clockwise or counter-clockwise (in the example shown, clockwise is chosen). Next, the user decides the number of spaces to advance (in this case, 4 space to point B) in the direction chosen in the prior step. The user110further decides the number of spaces (in this case 3 space from point C to point D) to advance in the opposite direction. The user can also set and decide if shaded segments are skipped (which is more apparent in the case ofFIG.4and not shown as part of the example inFIG.3). The system will assume the user110switches layers when going in opposite directions. For example, when on outer layer switch to inner layer, and vice versa. The sample pattern selection by user110is shown inFIG.3B, that is 7024019

The user interface400shown inFIGS.4A and4Bpresent another example where shade segments are presented and skipped as part of the encoding and decoding. In the example ofFIG.4B, the following settings can exist:(1) Select start position on widget=A(2) Decide to first go clockwise or anti-clockwise=Clockwise(3) Decide the number of segments to cover in direction chosen in step 2=5(4) Decide the number of segments to cover in the opposite direction=3(5) Decide if shaded segments are skipped=NO

In the example ofFIG.4B, the user110starts at position A on an outer layer, goes clockwise to cover five segments and stops at position B. Switches to inner layer, to point C, and goes in an opposite direction (now counter-clockwise) and covers 3 segments before stopping at point D.

The value entered through keyboard or user interface400will be 70246301 (when the setting for skipping shaded segments were disengaged or set to “NO”) which corresponds to all the segments that are between points A and D. 70246301 is also the value sent back to server112by the widget app104as part of data exchange (seeFIG.1).

Each time widget app104displays the graphic user interface (circular or otherwise), the actual numbers inside each segment of the inner and outer circles will be different. Hence the value of data exchange will be different, for the same pattern. This makes such a system less prone to hacking.

Another variant of this pattern matching is when the user110elects to skip any shaded segments (when the skip shaded segments is set to “YES”), which further mitigates attempts at hacking. Also, the number of segments to cover in the first direction is set to 4. InFIG.4B, one segment on the outer layer is shaded. Since the user110elected to skip this in this example, the value entered through keypad will be, different. It will now be: 7046301. Note the position of segments B, C, and D in this figure compared to previous positions inFIG.3B.

The widget app104can randomly display zero, one, or more segments in shaded color. Since the numbers in each segment and their shading comes from the data processing app114, the data processing app114can determine if the patterns was the right pattern.

Approach 2: Known Pattern, Entered Graphically

This approach is similar to first approach in that user110selects a pattern. This pattern is then conveyed graphically by direct manipulation of the widget application104and corresponding user interface.

The direct manipulation can be through a touch screen, or markers that move from one segment to another in response to the user110clicking clockwise/counter-clockwise buttons on the widget or entering characters on a keyboard corresponding to the characters shown and uploaded to the pattern in the user interface (200,300, or400).

The widget app104may also include the shaded numbers in the data exchange sequence sent to data processing app114. For example, corresponding toFIG.4B, the data sequence sent can be 70246301 instead of 7046301. Note that now it is an eight-digit value instead of a seven-digit value. One extra digit is for the shaded segment, which is skipped, but the value is still included. The data processing app114will strip the shaded value off before comparing the submitted pattern to a stored template pattern.

Approach 3: Known Value, Entered Graphically

In this approach, the user does not remember a pattern, but knows an actual value that has to be entered in the widget app104. The value has to be entered in such a sway that it is protected from keystroke loggers, shoulder surfers, and any packet sniffers on the network.

This user interfaces500and600in these embodiments are shown inFIGS.5and6.

FIG.5shows a user interface500with a single dial for data entry. Since it is single dial, all characters that can be entered have to fit in this dial. The user interface can further include a selection position and pause timer502.

FIG.6shows a user interface600with a more complex dial consisting of more than one layer including a selection position and pause timer602. The need for multiple dials arises since the character set of possible values can be large (e.g. lower case, upper case, numeric, special characters, etc.) and fitting them on a single dial may not be practical.

The user110(or client device102) and server112can negotiate rules of entering data as follows:

Decide if data is entered when rotating clockwise or counter-clockwise

Decide the pause timer value, which will register a character entry

Once these two are agreed, the user is free to rotate the dials arbitrarily, and as many times as they want. This can be done to confuse the shoulder surfers and keystroke loggers. There can be several mechanisms for dial rotation, such as direct interaction with touch screen, clicking on clockwise/counter-clockwise button on the widget app, etc. In case of multiple dials, each can be rotated independently. A visual indication can be provide to the user to show which dial is in active state, and which segment on that dial has the focus. In case the focus remains for an interval agreed upon between user and server under rules of data entry, the value in that segment is marked as implicated selected by user.

When the dial is turned, and a new segment gets the focus, the timer display (502or602) is reset to “0”. This timer starts ticking with the passing of each second, showing the current lapsed time in seconds. This reflects the “pause” in dial rotation. If the pause is less than one second, it is not recorded. For all other cases the widget app104can build the following table700as shown inFIG.7which includes a layout and fields of the table to record data entry.

The columns in table700can include an “Entry index” which is a sequentially incrementing number, a “Direction” which is the direction of dial rotation after which a character was selected. It can be clockwise or counter-clockwise. The widget can use a code for direction instead of actual “clockwise” text. For example, 0 for clockwise and 1 for counter-clockwise.

A “Circle index” indicates which circle was active. For example, outer circle with capital letters, middle circle with lower case letters, or an inner circle with numbers and special characters. The circle index is known by both widget application104and server112, and can be any value as long as it is consistently used in one rendering of the widget. The index values can be random, and different for each display of the widget. Since these values are set by the server, the server can comprehend the data returned to it by the widget app.

A “Segment index” identifies the segment within the current circle or the circle index. This will not indicate the actual visible value in that segment, but index of this segment from the start. For example first segment on outer circle that has a visible text of “A” has an index of 1. Sixth segment on the same outer circle has the visible text of “F” but this will be represented by Segment index of 6.

The “Pause timer” column simply represents the number of seconds the dial rotation was paused.

The widget app104can capture all these interactions and forward the indexed data to the corresponding table to and at the data processing application114at server112. The widget app104can also add its own “noise” that is outside the selections made by the user, as long as it does not get picked up by data processing app as a valid user selection.

One example of this table generated in response to dial rotation by the user110is shown in table800ofFIG.8. The actual recorded values are shown in one designation and the noise or discarded values are shown with a different designation. This noise can be a result of user interaction, or injected by the widget app itself to obfuscate data transmitted to server.

In the example shown inFIG.8, the entry rules are:

Selected direction of rotation=CLOCKWISE

Pause timer=2 to 4 Seconds

The index and direction convention used are:

Direction=Clockwise=0, counter-clockwise=1

Circle index=Outer=1, middle=2, inner=3

Segment index=segments in each circle start at 1, and increment clockwise.

The sample table shown inFIG.8is formed in response to user110entering “Apple 1”

The value of “Apple 1” is constructed by picking up rows 2, 4, 7, 8, 10 and 11 from Table800. This is done at the data processing app114on the server112.

The rest of the rows are not picked because they either had wrong direction or pause time was outside the desired or designated range.

Referring toFIG.9A, a flow diagram900illustrates how a client edge device can be initialized with an application or widget app in accordance with the embodiments. Initially, a server can generate rules and create a pattern template as part of a data exchange. The user can further modify or select the template and rules at the client application that can apply and further communicate such rules and pattern back to the server. The server can then further store the template with (the user) selected rules and pattern before the initialization is deemed complete.

In one example where secure data entry is done with a known pattern as illustrated in the flow diagram920ofFIG.9B, the server (or data processing application at the server) stores a pattern template at the server and sends the pattern embedded with characters to the client application. The user then selects the characters based on the known pattern and rules (as may have been set in the flow diagram900ofFIG.9A). The client application accordingly sends the characters corresponding to the user selected characters (that were based on the known pattern and rules). If the characters sent by the client match the characters stored in the template at the server, the server then grants access to a restricted resource (113a) at the server or otherwise (113b) controlled by the server.

In another example where secure data entry is done with a known value selected graphically as illustrated in the flow diagram940ofFIG.9C, the server (or data processing application at the server) stores a pattern template and rules at the server and negotiates the rules of decoding with the client application. The user enters a known character sequence on a graphic pattern input user interface on the client application at the client edge device. As part of the data entry process by the user on the client application at the client edge device, an index table can be built reflective of the data enter by the user. In one embodiment, the client application can send index values corresponding to the graphic pattern entry to the server. In an alternative embodiment, the client application can instead decode the index and send the characters to the server. The server would decode the index using the template and rules (if needed) or in the alternative embodiment the server would directly compare the characters with characters stored in the template. The server would then grant access to a restricted resource (113a) at the server or otherwise (113b) controlled by the server if the decoded characters (or characters in the alternative embodiment) matches the characters store in the template at the server. The restricted resource113bcan be remote to the server112, but otherwise controlled in terms of access by the server112.

The embodiments will be beneficial and will make an impact in various scenarios including1. PIN codes entered on cash machines can also be recovered by analyzing the residual heat left behind on the keypads. So this invention will be very useful for banking transaction in ATM machines2. Hardware Security Module's (HSM's) keypad to enter PIN,3. Enhance security for Keyless door locks4. Sitting in a public place and paying a bill or making a purchase over a cellphone and we entered passwords, credit card PIN5. Many more such cases etc . . . .

Such new input method will enhance the security for a user to enter sensitive information to access system and will make retrieving the data impossible or at least much more difficult.

In the embodiments, input values stored in a database can be hashed and encrypted for implementation perspective.

The embodiments provide a unique input method to enter short sensitive information (e.g. password, PIN, Messages etc.) on almost any access device.

In some embodiments and with reference toFIGS.1-11, a system100or method (920,940,1000,1100) of secure data entry can include one or more processors and memory having computer instructions which when executed by the one or more processors causes the one or more processors to perform the operations at a client edge device102of executing a user interface data entry application104on the client edge device, receiving data by the user interface data entry application, where the data entered is a graphic input pattern (200—A to B, or300—A to D,400—A to D) corresponding to alphanumeric digits, communicating the data entered to a server112, and receiving access to (a restricted resource113aor113b) controlled by the server112when a data processing application114at the server112interprets the data entered as a credential. Note that in accordance with some of the embodiments, either the graphic pattern or the underlying characters associated with the graphic pattern will vary in each instance to provide additional security (and obfuscation).

In some embodiments, the user interface data entry application104receives a sequence of random or pseudo-random alphanumeric characters from the server114for populating the graphic input pattern in a random or pseudo-random fashion and the client edge device102transmits back to the server112a portion of the sequence of the random or pseudo-random characters corresponding to a graphic template previously stored at the server when the graphic input pattern entered at the client edge device matches the credentials matching a set of alphanumeric characters stored corresponding to the graphic template at the server112.

In some embodiments, the graphic input pattern (200,300, or400) is a circular pie containing a plurality of slices where each slice corresponds to a user selectable slice selectable by swiping by the slice, or clicking on the slice, or entering a sequence of characters on a keyboard corresponding to characters populated in the slices of the graphic input pattern.

In some embodiments, the graphic input pattern is a circular pie containing a plurality of slices, where each slice corresponds to a user selectable slice selectable by swiping by the slice or clicking on the slice or entering a sequence of characters on a keyboard corresponding to characters populated in the slices of the graphic input pattern for a predetermined number of consecutive slices in a clockwise or counterclockwise direction as defined by rules set apriori between the client edge device102and server112.

In some embodiments as shown inFIG.3A,3B,4A, or4B, the graphic input pattern has at least two layered circle patterns containing a plurality of segments, where each segment corresponds to a user selectable segment selectable by swiping by or clicking on segments on at least a first layer for a predetermined number of consecutive segments in a clockwise or counterclockwise direction and subsequently swiping by or clicking for another predetermined number of consecutive segments on a second layer in a direction opposite from the direction used for the first layer. The rules can define a number of parameters or settings such as selecting a start position, which layer is considered first (outer or inner or a certain numbered layer), which direction is consider first (clockwise or counterclockwise), how many steps or slices are selected in a particular first direction (e.g., 1, 2, 3, etc.), how many steps or slices are selected in a direction opposite the first direction (e.g., 1, 2, 3, etc.), how many characters are to be considered per segment or slice (e.g., 1, 2, 3, etc.), and whether shaded segments are to be skipped (e.g., YES or NO or 1 or). Any number of parameters can be part of the rules negotiated between the client device and server.

In some embodiments having just a single layer as inFIG.2B, the user interface data entry application can include settings for selecting a start position, an initial rotation direction for a first layer of a circular input pattern, and a number of consecutive segments to advance in the initial rotation direction for the first layer.

In some embodiments having more than a first layer as illustrated inFIG.3B, the user interface data entry application can further include settings for selecting a number of segments to advance in an opposition direction from the initial rotation direction on a second layer of the circular input pattern.

In some embodiments having shaded segments as shown inFIG.4B, the user interface data entry application can further include settings for skipping shaded segments which can be done with shaded segments on either the first layer or the second layer or on both layers or on any number of layers in a multi-layered pattern.

In some embodiments, the user interface data entry application receives a sequence of alphanumeric digits from the server for populating the graphic input pattern in a known pattern (instead of random pattern) and the client edge device receives access to the server when it transmits back to the server a portion of the sequence of the alphanumeric digits corresponding to a graphic template previously stored at the server if the graphic input pattern entered at the client edge device matches the credential matching a set of alphanumeric numbers stored at the graphic template at the server based on rules negotiated and set between the client edge device and server. In this embodiment, a distinguishing aspect between this embodiment and other embodiments previously described can be that the known pattern include not only a known graphic pattern, but a known sequence of numbers that may not change in sequence. Thus, it may not be considered as secure as other embodiments, but the applied rules negotiated between the client edge device and server may still provide a higher level of security than just a pre-existing known pattern and known sequence of underlying characters since the system will also need to know the negotiated rules as well (skipped shaded segments, which layer or tier to consider, etc.).

In some embodiments as shown inFIG.9B, the user interface data entry application initially communicates the graphic input pattern as a template pattern to the server and the user interface data entry application subsequently receives from the server a plurality of characters such as alphanumeric digits for randomly occupying each of the segments of the graphic input pattern and where the client edge device in response to user input of correct credentials in graphic form sends a sequential listing of alphanumeric digits to the server corresponding to the template pattern with corresponding matching alphanumeric digits therein.

In some embodiments, the user interface data entry application generates a graphic user interface (500or600as shown inFIG.5or6respectively) having a movable and selectable graphic pattern or patterns with a plurality of segments populated with alphanumeric characters selectable by manipulation of the selectable graphic pattern and pausing on a particular alphanumeric character for a predetermined threshold time frame for selection.

In some embodiments, the user interface data entry application (104) includes settings for selecting an initial rotation direction (clockwise or counter-clockwise) and for selecting a pause timer value used for registering a character entry. The selection by the user can populate an index table700or800as shown in respectiveFIG.7or8.

In some embodiments, the movable and selectable graphic patterns600has at least two layered circle patterns as shown inFIG.6containing a plurality of segments, where each segment corresponds to a user selectable segment having a corresponding alphanumeric character that is selectable by rotating one or more dials, each dial corresponding to each layer of the at least two layered circle patterns and where each dial can be independently rotated. In some embodiments, the layers may not be able to be independently rotated and a separate column on an index table may be added to reflect such status. In some embodiments, the user interface data entry application104captures user interactions with the one or more dials and constructs a table800as illustrated inFIG.8including an entry index, direction, circle index, segment index and pause timer to decode a data entry for credentials according to predefined rules coordinated between the user interface data entry application (104) on the client edge device102and the data processing application (114) at the server112.

In some embodiments, a system of secure data entry can include one or more processors and memory coupled to the one or more processors, where the memory includes computer instructions which when executed by the one or more processors causes the one or more processors to perform the operations at a data processing application at a server112of executing the data processing application114at the server, exchanging data between the data processing application and a user interface data entry application on a client edge device as shown in the flow diagram940ofFIG.9C, receiving data from the client edge device from the user interface data entry application, wherein the data entered at the client edge device results from a graphic input pattern corresponding to alphanumeric characters stored at the server, and providing access to a restricted resource (113aand/or113b) on or controlled by the server112when a data processing application at the server interprets the data entered as a credential.

In some embodiments, the server112sends the user interface data entry application104a sequence of random or pseudo-random alphanumeric digits for populating the graphic input pattern in a random or pseudo-random fashion and the server receives back from the client edge device a portion of the sequence of the random or pseudo-random digits corresponding the graphic input pattern entered at the client edge device and where access is granted to the restricted resource (113aor113b) on or controlled by the server if alphanumeric characters from the graphic input pattern entered at the client edge device matches alphanumeric characters at a graphic template previously stored at the server (seeFIGS.9B and9C).

In some embodiments, the data processing application at the server initially receives from the user interface data entry application the graphic input pattern as a template pattern and the server subsequently sends to the user interface data entry application at the client edge device a plurality of alphanumeric digits for randomly occupying each of the segments of the graphic input pattern, and where the client edge device in response to user input of correct credentials in graphic form sends and the server receives a sequential listing of alphanumeric digits corresponding to the template pattern with corresponding matching alphanumeric digits therein (see flow diagram940ofFIG.9C).

In some embodiments, the user interface data entry application104generates a graphic user interface (500or600as shown inFIG.5or6respectively) having a movable and selectable graphic pattern or patterns with a plurality of segments populated by the server with alphanumeric characters selectable by manipulation of the selectable graphic pattern and pausing on a particular alphanumeric character for a predetermined threshold time frame for selection and the user interface data entry application further generates and sends data to populate an index table (700or800ofFIG.7or8respectively) corresponding to the data entered using the graphic user interface where the server uses the data from the index table (800) to decode the data selected by the user interface data entry application104and received by the data processing application114at the server112.

In some embodiments as illustrated byFIG.10, a method1000of secure data entry can include the steps of executing at1002a user interface data entry application on the client edge device wherein the user interface data entry application generates at1004a circular pattern (in a particular embodiment) having a plurality of selectable segments and where each selectable segment contains a corresponding character correlated in pattern or sequence between the user interface entry application at the client edge device and a data processing application at a server, receiving data at1006by the user interface data entry application, and communicating at1008to the server the data entered and processed at the user interface data entry application. The method1000can further include the step1010of receiving access to a restricted resource on the server if the data processing application at the server interprets the data entered at the client edge device as a credential corresponding to a previously stored credential. In some embodiments, the data entered by the user interface data entry application can be encrypted at1007to provide a more robust and secure system.

In some embodiments, the circular pattern noted at block1004having the plurality of selectable segments actuates the selection of a sequence of corresponding characters by either selecting a graphic pattern formed from a sequence of adjacent selectable segments (as in the patterns200,300, or400inFIG.3,4, or5) or by rotating one or more layers of segments to a selection position and pausing at the selection position for a predetermined threshold period before further rotating the one or more layers of segments as illustrated in another embodiment of the graphic pattern as shown in the patterns500or600inFIG.5or6respectively).

Referring toFIG.11, a method1100of securely entering data from a server perspective is illustrated. At1102, a server such as server112executes a data processing application (such as application114). In some embodiments, the method at1104can store a graphic pattern and/or sequence as a template correlated with a plurality of selectable segments where each selectable segment contains a corresponding character correlated in pattern or sequence (or even both in some embodiments) between the user interface entry application and a data processing application at the server. At step1106, the server can receive data entered and processed at the user interface data entry application. At decision block1108, if the data entered is indicative of a credential (password, pin, etc.), then decision block1110further determines if the data entered matches a stored credential at the server. If a match exists at decision block1110, then the server can grant access to the server or a restricted resource (113a) at the server or at a remove location (113b) controlled by the server. If at decision block1108, the data processing application at the server determines that the data entered is not a credential, then the server will process the data as something other than credential data at block1109. If the apparent credential data at decision block1110does not match a stored credential, then the server112will deny access to the restricted resource (113aor113b) and possibly to the server itself.

In the absence of any specific clarification related to its express use in a particular context, where the terms “substantial” or “about” or “usually” in any grammatical form are used as modifiers in the present disclosure and any appended claims (e.g., to modify a structure, a dimension, a measurement, or some other characteristic), it is understood that the characteristic may vary by up to 30 percent.

The terms “include” and “comprise” as well as derivatives thereof, in all of their syntactic contexts, are to be construed without limitation in an open, inclusive sense, (e.g., “including, but not limited to”). The term “or,” is inclusive, meaning and/or. The phrases “associated with” and “associated therewith,” as well as derivatives thereof, can be understood as meaning to include, be included within, interconnect with, contain, be contained within, connect to or with, couple to or with, be communicable with, cooperate with, interleave, juxtapose, be proximate to, be bound to or with, have, have a property of, or the like.

Unless the context requires otherwise, throughout the specification and claims which follow, the word “comprise” and variations thereof, such as, “comprises” and “comprising,” are to be construed in an open, inclusive sense, e.g., “including, but not limited to.”

Reference throughout this specification to “one embodiment” or “an embodiment” or “some embodiments” and variations thereof mean that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment. Thus, the appearances of the phrases “in one embodiment” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” include plural referents unless the content and context clearly dictates otherwise. It should also be noted that the conjunctive terms, “and” and “or” are generally employed in the broadest sense to include “and/or” unless the content and context clearly dictates inclusivity or exclusivity as the case may be. In addition, the composition of “and” and “or” when recited herein as “and/or” is intended to encompass an embodiment that includes all of the associated items or ideas and one or more other alternative embodiments that include fewer than all of the associated items or idea.

In the present disclosure, conjunctive lists make use of a comma, which may be known as an Oxford comma, a Harvard comma, a serial comma, or another like term. Such lists are intended to connect words, clauses or sentences such that the thing following the comma is also included in the list.

As the context may require in this disclosure, except as the context may dictate otherwise, the singular shall mean the plural and vice versa. All pronouns shall mean and include the person, entity, firm or corporation to which they relate. Also, the masculine shall mean the feminine and vice versa.

When so arranged as described herein, each computing device or processor may be transformed from a generic and unspecific computing device or processor to a combination device comprising hardware and software configured for a specific and particular purpose providing more than conventional functions and solving a particular technical problem with a particular technical solution. When so arranged as described herein, to the extent that any of the inventive concepts described herein are found by a body of competent adjudication to be subsumed in an abstract idea, the ordered combination of elements and limitations are expressly presented to provide a requisite inventive concept by transforming the abstract idea into a tangible and concrete practical application of that abstract idea.

The headings and Abstract of the Disclosure provided herein are for convenience only and do not limit or interpret the scope or meaning of the embodiments. The various embodiments described above can be combined to provide further embodiments. Aspects of the embodiments can be modified, if necessary to employ concepts of the various patents, application and publications to provide further embodiments.