Patent Publication Number: US-2010111292-A1

Title: Aggregate and parallelizable hash function

Description:
FIELD 
     The following relates to a hash function which provides the aggregation property and for which computation can be parallelized. 
     RELATED ART 
     Hash functions can be used for a variety of purposes in the areas of authentication, encryption, document signing and so on. Properties of hash functions for most such purposes have a baseline common set of desirable characteristics. These characteristics include preimage resistance, meaning that it is difficult to determine a document that can be hashed to a specified hash value. Another characteristic is second preimage resistance, meaning that it is difficult to find a second input that hashes to the same hash value as a specified input. A related characteristic is that different documents should reliably produce different hash values (non-collision). 
     Another, less common, property of hash functions used in the area of encryption and other related data security fields is aggregation. Most hash functions used in the field of data security require recomputation of the hash of an entire message when further data is appended to the message. Values produced in computing the hash of the original message generally are not reused in computing the hash of the appended message. A hash function that has the property of aggregation, however, can use values produced during computation of a hash value for an original message when computing the hash for the appended message. 
     Hash functions with these properties remain the subject of ongoing research, and further advancements in this area are useful. 
     SUMMARY 
     The following relates to providing a hash function that can meet principal desired hash properties, including preimage, second preimage, and collision resistance, while also providing other properties that can be desirable in some applications including aggregation (e.g., providing a hash of a file comprising an original dataset and a dataset appended thereto) as well as parallelization. The aggregation property of the hash function can be useful in situations where portions of a given message are streamed over a period of time to a receiving entity, or where a file may be appended frequently, such as a log file. 
     In a first aspect, a method for hashing a message comprises accessing a first 2×2 matrix A and a second 2×2 matrix B. The matrices A and B are each selected from the Special Linear group SL 2 (R). R is a commutative field defined as R=F 2 [x]/(P), with F 2 [x] being the set of polynomials having coefficients selected from the set of F 2 ={0,1}, and (P) being the ideal of F 2 [x] generated by an irreducible polynomial of order n. 
     The method further comprises accessing a message M as a sequence of bits. The method also comprises producing a multiplicative matrix sequence by substituting one of the B matrix and the A matrix either for binary 0 bits or for binary 1 bits in M, and substituting the other of the B matrix and the A matrix for the other of binary 0 bits and binary 1 bits. Alternatively expressed, A and B can be selected arbitrarily from suitable matrices, and one of A and B is substituted for binary 0 bits, and the other of A and B is substituted for the binary 1 bits in M. 
     The method further comprises computing the product of the matrices in the sequence to produce a 2×2 matrix (h). Each element of h has n bits. The method further comprises rearranging the bits of h into an l by l matrix Y, and computing g=PYQ —1 . P and Q are each invertible l by l matrices with elements randomly chosen from F 2 . The calculated g value, or a value derived therefrom, is outputted as the hash for the message M. 
     As an example of the aggregation property provided by hash functions according to these disclosures, the method may further comprise producing a second matrix sequence for a message M 2 , that is to be concatenated with an M 1 , and computing the product of the matrices in the second matrix sequence to produce a 2×2 matrix (h 2 ). Each element of h 2  has n bits. The method also comprises multiplying an h 1  produced for M 1  and h 2  to produce a 2×2 matrix h 12 ; each element of h 12  also has n bits. The method also comprises rearranging the bits of h 12  into an l by l matrix Y 12  and computing g′=PY 12 Q −1  as a hash for the concatenation of message M 1  and M 2 . This example can be extended to a large number of message portions, such that hash computation can be distributed among a plurality of processing resources. 
     The bit rearranging step of the method can be performed by an invertible defolder function. The defolder function in some cases receives a 2×2 matrix, with each element having n bits, and outputs the l by l matrix Y having a total of 4n bits. In other cases, the defolder function can compress or expand the number of bits either inputted or outputted. 
     An entity can recover h from g=PYQ −1  by using an inverse of F, an inverse of P, and Q. Q is invertible and computing its inverse, Q −1 , is straightforward. There can be a unique P and Q pair pre-shared between each pair of entities seeking to exchange messages and hashes thereof. An entity seeking to validate a message using a g value calculated therefore can independently calculate a g value based on the data received for the message and compare the g values, or the entity can recover the h value and compare a computed h to the recovered h. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  depicts an arrangement comprising a plurality of systems that can exchange messages and hash values that can be used by systems receiving the messages to validate the messages; 
         FIG. 2  depicts data flow and method steps for a first example method; 
         FIG. 3  depicts steps of a method for initializing entities, such as transmitting and receiving devices, to perform implementations of the hashing operations described herein; 
         FIG. 4  depicts steps of a second method including various hashing options, and which can be implemented in a transmitting device; 
         FIG. 5  depicts steps of a method that can be implemented in a system receiving messages and hash values that can be generated according to the methods of  FIGS. 2 and 4 , and using the hash values for message validation; and 
         FIG. 6  depicts components that can form an example system that can be used in the arrangement of  FIG. 1 . 
     
    
    
     DESCRIPTION 
     The following relates to providing a hash function that can meet principal desired hash properties, including preimage, second preimage, and collision resistance, and which also has the aggregation property (providing a hash of a file comprising an original dataset and a dataset appended thereto with reuse of at least some values computed during the computation of the hash for the original dataset), and/or parallelization (concurrently performing computations of a hash function for a message in multiple processing resources). 
     Many hash functions well-known in the area of data security and encryption, such as MD5 and SHA-1, operate on blocks of message data. For example, MD5 operates on 512 bit blocks and produces a 128 bit hash value. These hash functions do not provide the aggregation property. Larger data sets, such as audiovisual information (e.g., streaming media, logging functions, and so on), can benefit from a hash having aggregate properties. A Tillich-Zemor hash function operates instead on a bitstream, and aspects concerning this hash function are described in more detail in an example depicted in  FIG. 2  and described below. 
       FIG. 1  depicts an example context in which hash functions according to these disclosures can be used. In  FIG. 1 , an entity E 1  may communicate with a plurality of other entities E 2 , E 3 , through E n . E 1  can send a message to entities E 2 , through E n , and produce a hash for the message according to these disclosures. Each of these entities represents an abstraction for any of a variety of devices, functions, software, and so on. For example, each entity may comprise hardware and/or software implementing a device, such as a computer, a cell phone, a processor, a processor core, a display, and so on. An example of structure comprised in the entities of  FIG. 1  is provided in  FIG. 6 . 
     In the particular example of  FIG. 1 , E 1  distributes information (referred to as a message herein) to E 2 , through E n , and creates a hash for the message. In some examples, a hash for the same message can be made different for each of E 2 , through E n  using a methodology described below. 
       FIG. 2  depicts a data flow and steps for a first example method  200  according to these disclosures. Method  200  operates on a binary message M (can be a binary representation of arbitrary data, such as compiled code, source code, text, video, audio, and so on) to produce a hash value g. In step  205 , the message M is accessed and parsed bit by bit. 
     For each bit of M, one of two 2×2 matrices, A and B, is substituted (step of mapping  210 ) for that bit. For example, step  210  may comprise substituting the B matrix for each 0 bit (i.e., for each binary 0), and substituting the A matrix for each 1 bit (i.e., for each binary 1). Step  210  thus produces a sequence  255  of A and B matrices (which will be multiplied together in a later step). 
     The A and B matrices are chosen/formed as follows. P(x) is a polynomial that is defined over the field of polynomials having coefficients selected from F 2 ={0,1} (i.e., all coefficients of P(x) are either 1 or 0). P(x) is irreducible. The symbol α denotes a root of P(x). In an example, P(x)=x 256 +x 127 +x 23 +x 13 +1. Each element of each A and B matrix can be represented as an n-bit sized buffer for the purposes of implementing the hash. 
     The matrices A and B each can be selected from a set of matrices comprising matrices that each has been created to have the properties described above. The set of matrices may comprise the matrices 
     
       
         
           
             
               ( 
               
                 
                   
                     1 
                   
                   
                     α 
                   
                 
                 
                   
                     0 
                   
                   
                     1 
                   
                 
               
               ) 
             
             , 
             
               ( 
               
                 
                   
                     α 
                   
                   
                     1 
                   
                 
                 
                   
                     0 
                   
                   
                     0 
                   
                 
               
               ) 
             
             , 
             
               
                 ( 
                 
                   
                     
                       α 
                     
                     
                       
                         α 
                         + 
                         1 
                       
                     
                   
                   
                     
                       1 
                     
                     
                       1 
                     
                   
                 
                 ) 
               
                
               
                 
                   ( 
                   
                     
                       
                         
                           α 
                           + 
                           1 
                         
                       
                       
                         α 
                       
                     
                     
                       
                         1 
                       
                       
                         1 
                       
                     
                   
                   ) 
                 
                 . 
               
             
           
         
       
     
     Each of A and B would be selected from the set without replacement, such that A and B are different. 
     Returning to  FIG. 2  and method  200 , sub-sequences of repeating binary 0&#39;s or binary 1&#39;s can be further mapped (step  215 ) into respective powers of B or A, producing the multiplicative matrix sequence  256 , which comprises matrices raised to a power greater than or equal to 1. This sequence  256  is to be multiplied in order (step  220 ) to produce a hash value, h. The steps  210 ,  215 , and  220  together can be considered a hash function H(M), which operates on the message M and returns the hash value, h. 
     In the example shown in  FIG. 2 , if M=100011001, the hash value his determined as H(M)=A·B 3 ·A 2 ·B 2 ·A (if step  215  is performed) and as H(M)=A·B·B·B·A·A·B·B·A (without step  215 ). The number of bits in the hash value h depends on the degree n of the polynomial P(x). For any M, h has a total of 4n bits, arranged as a 2×2 matrix, where each element has n bits. In these disclosures, 
     
       
         
           
             
               n 
               = 
               
                 
                   l 
                   2 
                 
                 4 
               
             
             , 
           
         
       
     
     where l has the meaning/usage described below. The degree of P(x) can be 256. 
     In step  225 , a de-folder function F( ) is defined to input h and output a square l×l matrix, Y. Thus, by requiring 
     
       
         
           
             
               n 
               = 
               
                 
                   l 
                   2 
                 
                 4 
               
             
             , 
           
         
       
     
     the produced h value has 4n bits, and h can be used to generate the desired l×l matrix output. F( ) is invertible. A simple F( ) can comprise parsing h into l bit segments, and arranging them into entries of the l×l matrix. F( ) can implement more complicated rearrangements of the bits of h, as desired. For example, F( ) can shuffle or otherwise transpose bits of h into an order different from an implied order of the bits in h. In an implementation n can be 256, so that l=8. 
     As will be made evident below, F( ) also can be selected to have the property of associativity, such that F(h 1 *h 2 )=F(h 1 )F(h 2 ), where h 1  is a first hash from a first message (or message portion), M 1 , and h 2  is a second hash from a second message (or message portion), M 2 . F( ) can be selected to avoid either compressing or expanding the inputted bits. Alternatively, some implementations may benefit from expanding or compressing the inputted bits. 
     Returning now to  FIG. 2  and method  200 , the matrix Y outputted from step  225  is premultiplied (step  230 ) by an l×l matrix P and postmultiplied (step  230 ) by an l×l matrix Q −1 . G is defined based on this pre and post multiplication as G(M)=PF(H(M))Q −1 . For message M, where h=H(M), G(H(M) produces a final hash g. 
     Both P and Q are to be invertible and their values randomly chosen from F 2 . 
     Returning to  FIG. 1 , if E 1  wishes to transmit the message M, to E 2 , and to provide a hash value for it, E 1  can compute g=G(M)=PF(H(M))Q −1  according to the steps of method  200 , and transmit g as the hash for M. The usage of a unique pair of P and Q for each pair of communicating entities provides that only the entities of that pair can compute valid hash data for that pair of P and Q. 
     E 2  receives data intended to comprise the message (the data received identified as M E2 , allowing that it may be different from M). E 2  can verify that the message was received properly, including that it was not corrupted or intentionally altered during transmission by separately hashing g E2 =G(ME 2 )=PF(H(ME 2 ))Q −1  and checking whether g E2 =g. If they match, then it can be decided that M=M E2 . In this usage model, E 1  and E 2  would pre-share the P and Q used (their inverses also can be pre-shared or calculated, given P and Q). A further example is that E 2  could compute H (M) from g, (because P and Q are invertible), separately compute H(ME 2 ), and determine whether H(M) and H(M E2 ) match. 
     Aggregates 
     The disclosed hash function can be used in a variety of situations where it is desirable to provide hash aggregates. 
     In a first example, E 1  desires to produce hashes for two messages, M 1  and M 2 , and provide the hashes to E 2  with the messages. E 1  can separately compute g 1 =PF(H(M 1 ))Q −1  and g 2 =PF(H(M 2 ))Q −1  according to method  200 , above. 
     E 1  can transmit both M 1  and M 2 , and both g 1  and g 2  to E 2 . The data received at E 2  is identified respectively as M 1-E2 , M 2-E2 , g 1-E2  and g 2-E2 , allowing that any of the data transmitted could have been tampered with or corrupted. M 1  and g 1  may be calculated and/or transmitted at a different time than M 2  and g 2 . In some cases, h 1  or Y 1 =F(h 1 ) can be calculated prior to determining that E 2  is to receive M 1 . After it is determined that E 2  is to receive message M 1 , the P and Q pre-shared between E 1  and E 2  may be accessed, and g 1  may be created. 
     E 2  may need to be able to verify M 1-E2  when it is received, M 2-E2  when it is received, as well as verifying the concatenation of M 1  and M 2  when both have been received. It also would be desired to use the computations performed to verify M 1  to verify the hash for the entirety of M 1-E2  and M 2-E2 . 
     In verifying M 1-E2  with g 1-E2 , E 2  can compute F(h 1-E2 ) (i.e., performing hash H( ) on received M 1-E2 ), perform the pre and postmultiplication respectively with P and Q −1  (i.e., computing PF(H(M 1-E2 ))Q −1 ), and compare g 1-E2  with the computed PF(H(M 1-E2 ))Q −1 . 
     To verify the concatenation of M 1-E2  and M 2-E2 , E 2  can compute F(h 2-E2 ) (i.e., performing hash H( ) on received M 2-E2 ). E 2  also computes g 1 QP −1 g 2  and determines whether it equals PF(h 1 )F(h 2 )Q −1  (where F(h 1-E2 ) already was computed). Thus, E 2  avoids repeating computations required to produce h 1 . 
     Of course, in some implementations, a message may be segmented into many sub-parts, or a message may be streamed over a period of time, such that practical implementations would compute a large number of hashes over the course of a large data transfer, such as a video. Especially for computation constrained or power consumption constrained devices, avoidance of unnecessary computation is valuable, as it can allow using less powerful and often cheaper parts, provide longer battery life, and so on. 
     Another usage involves verifying an origin of an aggregation of message components, an example of which is presented below. In such a usage, E 1  computes g 3 =PF(h 1 )F(h 2 )F(h 1 *h 2 )Q −1 . In this usage, the operator * can provide for the output of F(h 1 *h 2 ) to be a 2×2 matrix, each element of such having n bits. As such, h 1 *h 2  can be implemented as a matrix multiplication, for example. In another example, h 1 *h 2  can be implemented as a concatenation, h 1 ∥h 2 , and F( ) also can compress the bits of the concatenation to 4n bits while performing the function of producing the matrix Y. 
     E 1  also computes g 4 =PF(h 1 ∥h 2 )Q −1 . E 1  sends g 1 , g 2 , g 3 , and g 4  to E 2 . E 2  determines whether g 3-E2 =g 1-E2 Q −1 Pg 2-E2 Q −1 Pg 4-E2  (all subscripts identifying “as received” values) to verify the source of the aggregation. 
     Other Variations 
     It was introduced with respect to  FIG. 2  above that there is a substitution of the matrices A and B respectively for binary 1 and binary 0 (or vice versa, since A and B are interchangeable and the designation is therefore for convenience) in a message M, then sequences of A and B matrices were replaced with powers of those matrices. Such powers can be pre-computed to speed up the multiplication in step  220  of method  200 . The steps of mapping the binary values to the matrices (step  210 ) and replacing with powers (step  215 ) were separately shown to better explain the example method. In implementations, there can be a direct substitution between strings of binary 1&#39;s or binary 0&#39;s with appropriate powers of the A and B matrices. 
     In a further implementation, a number of pre-computed multiplicative combinations of the A and B matrices can be provided. For example, W={A, A 2 , AB, B 2 , A 2 B, B 2 A, B 2 A 2  . . . A c B d } can be provided, where c and d can be any integers greater than or equal to 1, and each element in W is a 2×2 matrix. Having a wider variety of potential mappings between pre-multiplied combinations of the A and B matrices can increase speed and efficiency. For example, when parsing a message in order, there can be a number of substitutions of elements from W that are valid, and among these valid selections, a choice can be made. The choice can be made to increase speed. In some implementations, the choice can be made to provide random or pseudorandom selections of these pre-computed matrices. 
     COMPREHENSIVE METHOD EXAMPLE 
       FIG. 3  illustrates an initialization method  300 , which can be implemented partially at E 1 , and at partially at entities to be communicating with E 1  (example of E 1  communicating with any of E 2  through E n  is specific example of an any-to-any communication scheme among any of E 1  through E n ). 
     Method  300  includes picking (step  305 ) an A matrix and a B matrix from an available set of matrices. A set of multiplicative combinations of the selected A and B matrices (e.g., W) is produced (step  310 ). 
     Method  300  includes determining (step  315 ) respective P and Q combinations for each entity of E 2  through E n  to be communicating with E 1 . In other words, a distinct P and Q pair is generated for communication between E 1  and E 2  and so on. Optionally, inverses for each P and Q generated can also be determined in step  310 . Step  320  comprises sharing these P and Q combinations, and optionally their calculated inverses, with respective entities. Step  325  comprises receiving, at each respective entity, its P and Q combination. If inverses for P and Q were not transmitted, then each entity can calculate (step  330 ) those inverses. 
     A method  400  can be performed each time a message M is to be sent from one entity to another (e.g., from E 1  to E 2 ). Method  400  comprises receiving (step  415 ) or otherwise accessing the message M. Method  400  also includes segmenting (step  420 ) M into a plurality of blocks m 1 -m b . These blocks are distributed (step  425 ) among a plurality of processing resources (e.g., selections of one or more of different FPGAs, processing cores, threads, servers, and the like). Each such processing resource also has access to the selected matrices A and B, or receives those as well. Each block m 1 -m b  is parsed as a sequence of bits into respective multiplicative sequences of matrices (that can be selected from the matrices calculated in step  310  of method  300 , above). 
     A method for selecting each matrix to substitute for one or more bits of each message block m 1 -m b  may comprise maintaining a pointer to a current position in the string of bits comprising a given block being processed, and identifying several potential matrices that can be next selected. Each potential selection may represent a differing number of bits; for example A 2  represents 2 bits, while A 4  represents 4 bits, even though both are still 2×2 matrices. Then, a selection of one of these potential matrices is made, and that selection is added to the matrix sequence. The pointer is moved an appropriate number of bits, and the process is repeated. In some cases, the matrix can be selected based on which matrix represents a largest number of bits, e.g., BA 2  would be selected preferentially to BA if the bitstring at the current pointer location included “011 . . . .” 
     Returning now to  FIG. 4 , method  400  continues (concurrently in the processing resources) with producing (step  435 ) respective h 1  . . . h b  values for each of blocks m 1 -m b . The h 1  . . . h b  are multiplied together (step  436 ) to produce a final 2×2 h matrix. Then, the final h matrix is operated on by F( ), to produce Y. 
     Method  400  then comprises determining (step  445 ) which g values are to be calculated in this instance of method  400 . For example, all of E 2  through E n  ( FIG. 1 ) may need to receive M. Each of entity E 2  through E n  may be assigned a different respective P and Q matrix pair, each being preshared between E 1  and respectively one of E 2  through E n . So, a respective g value may be calculated for each of E 2  through E n . 
     Also, where it is desired to stream portions of the message, it may be desired to compute several intermediate g values for portions of M. For example, a g may be calculated for blocks on 1024 block intervals, e.g., a g can be calculated for m 1  . . . m 1024  for each of entities E 2  through E n . In producing the g value for m 1  . . . m 1024 , there can be an h value calculated concurrently for each of m 1  . . . m 1024  in different computing resources, and these h values can be used in arriving at g 1-1024 =PF(h 1 h 2  . . . h 1024 )Q −1 . 
     Also, it may be desired to provide hash origin verifiability, and so respective g 3  and g 4  hashes also can be calculated for each of E 2  through E n . Thus, method  400  illustrates the broad usage of the hash function aspects disclosed above, including using respective unique P and Q pairs between each pair of communicating entities, allowing hash aggregation, parallelization of computation, and origin verification. 
     Similarly, step  450  comprises accessing the P and Q combinations (pre-shared between E 1  and one of E 2  through E n ), and which are to be used in producing the g values that were determined in step  445 . Step  455  comprises calculating the g values, and step  360  comprises sending the g values to their respective entities. The send step  460  also may comprise identifying the g values, where multiple g values are included, so that they may be distinguished from each other. Such identification may be implicit in an ordering of a transmission. Also, an entity generating the hash values may provide information about what matrices were used to produce the hash values; for example, information to select the matrices from a known set of matrices can be provided. 
     Method  500  illustrates exemplary steps that can be performed by each of E 2  through E n  when receiving message(s) and hash value(s) to be verified from E 1 , and which may have been formed according to the steps of method  400 , above. 
     Method  500  comprises receiving one or more calculated g values, and as necessary, determining what the g values represent (e.g., a hash value for a single block, for a concatenation of blocks, for verifying origin, and so on). Method  500  further comprises receiving (step  510 ) data representative of a message or blocks (when aggregating) of a message. Step  515  comprises accessing the P and Q for the entity performing method  500 . Method  500  also comprises accessing (step  520 ) the selected A and B matrices that were used in producing the g value(s) provided. Such matrices can be the same for all g values or can vary. 
     Method  500  also comprises performing (step  525 ) calculations for verifying the message or message blocks for which g values were provided. These calculations can vary depending on which g values were provided, and for which blocks. For example, if a single message hash value g is to be verified, then method  500  may comprise determining a corresponding g for the message as received and comparing (step  530 ) them. Other calculations that can be performed are described above, and include calculations relating to hash aggregates, and origin verification. 
     If values calculated (step  525 ) can be successfully compared (step  530 ), then a positive determination (step  535 ) that the received message accurately represents the transmitted message can be made. Responsive to that determination (step  535 ), the message and/or components thereof can be validated (step  545 ). If there is a failure to obtain a successful comparison in step  530 , then the message or message components can be rejected as potentially invalid (step  540 ). 
     Method  500  can also comprise looping to step  505  where more g values can be received, which can relate to further received data (step  510 ). The looping thus illustrates that the reception of data to be validated can occur over a period of time, as would often be the case when using hash aggregation. 
     The exemplary ordering of steps in any flow chart depicted does not imply that steps necessarily be completed in that order. Any of intermediate values, or final values, or other data described as being generated or produced can be saved to a computer readable medium, either temporarily, such as in a RAM, or more permanently, such as in non-volatile storage. 
       FIG. 6  illustrates a computer system  600 , in communication with a second computer system  675 . Computer system  600  is an example of computer hardware, software, and firmware that can be used to implement disclosures below. System  600  includes a processor  620 , representative of any number of physically and/or logically distinct resources capable of executing software, firmware, and hardware configured to perform identified computations. Processor  620  communicates with a chipset  622  that can control input to and output from processor  620 . In this example, chipset  622  outputs information to display  640 , and can read and write information to non-volatile storage  660 , which can include magnetic media, and solid state media, for example. Chipset  622  also can read data from and write data to RAM  670 . A bridge  635  for interfacing with a variety of user interface components can be provided for interfacing with chipset  622 . Such user interface components can include a keyboard  636 , a microphone  637 , touch detection and processing circuitry  638 , a pointing device, such as a mouse  639 , and so on. In general, inputs to system  600  can come from any of a variety of sources, machine generated and/or human generated. 
     Chipset  622  also can interface with one or more data network interfaces  625 , that can have different physical interfaces  617 . Such data network interfaces can include interfaces for wired and wireless local area networks, for broadband wireless networks, as well as personal area networks. Some applications of the hashing disclosures herein can include receiving data from system  675  through physical interface  617  through data network  625 , and in preparation to store the data in non-volatile storage  660 , system  600  can calculate a hash value for the data, and use that hash value as an identifier for a file containing the received data. Further examples relating to file naming can include generating data through processing performed on processor  620 , and which is to be stored in RAM  670  and/or non-volatile storage  660 . 
     Methods according to the above-described examples can be implemented using computer-executable instructions that are stored or otherwise available from computer readable media. Such instructions comprise, for example, instructions and data which cause or otherwise configure a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. Portions of computer resources used can be accessible over a network. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, firmware, or source code. Examples of computer-readable media that may be used to store instructions, information used, and/or information created during methods according to described examples include magnetic or optical disks, flash memory, USB devices provided with non-volatile memory, networked storage devices, and so on. 
     Devices implementing methods according to these disclosures can comprise hardware, firmware and/or software, and can take any of a variety of form factors. Typical examples of such form factors include laptops, smart phones, small form factor personal computers, personal digital assistants, and so on. Functionality described herein also can be embodied in peripherals or add-in cards. Such functionality also can be implemented on a circuit board among different chips or different processes executing in a single device, by way of further example. 
     The instructions, media for conveying such instructions, computing resources for executing them, and other structures for supporting such computing resources are means for providing the functions described in these disclosures. 
     Although a variety of examples and other information was used to explain aspects within the scope of the appended claims, no limitation of the claims should be implied based on particular features or arrangements in such examples, as one of ordinary skill would be able to use these examples to derive a wide variety of implementations. Further and although some subject matter may have been described in language specific to examples of structural features and/or method steps, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to these described features or acts. For example, such functionality can be distributed differently or performed in components other than those identified herein. Rather, the described features and steps are disclosed as examples of components of systems and methods within the scope of the appended claims.