Implementation of the SHA-256 hashing function.  
More...
Implementation of the SHA-256 hashing function. 
 | 
| file   | sha256.h | 
|   | Header definitions for the SHA256 hash function. 
  | 
|   | 
 | 
| void  | sha256_init (sha256_context_t *ctx) | 
|   | SHA-256 initialization.  
  | 
|   | 
| static void  | sha256_update (sha256_context_t *ctx, const void *data, size_t len) | 
|   | Add bytes into the hash.  
  | 
|   | 
| static void  | sha256_final (sha256_context_t *ctx, void *digest) | 
|   | SHA-256 finalization.  
  | 
|   | 
| void  | sha256 (const void *data, size_t len, void *digest) | 
|   | A wrapper function to simplify the generation of a hash, this is useful for generating sha256 for one buffer.  
  | 
|   | 
| void  | hmac_sha256_init (hmac_context_t *ctx, const void *key, size_t key_length) | 
|   | hmac_sha256_init HMAC SHA-256 calculation.  
  | 
|   | 
| void  | hmac_sha256_update (hmac_context_t *ctx, const void *data, size_t len) | 
|   | hmac_sha256_update Add data bytes for HMAC calculation  
  | 
|   | 
| void  | hmac_sha256_final (hmac_context_t *ctx, void *digest) | 
|   | hmac_sha256_final HMAC SHA-256 finalization.  
  | 
|   | 
| void  | hmac_sha256 (const void *key, size_t key_length, const void *data, size_t len, void *digest) | 
|   | function to compute a hmac-sha256 from a given message  
  | 
|   | 
| void *  | sha256_chain (const void *seed, size_t seed_length, size_t elements, void *tail_element) | 
|   | function to produce a hash chain starting with a given seed element.  
  | 
|   | 
| void *  | sha256_chain_with_waypoints (const void *seed, size_t seed_length, size_t elements, void *tail_element, sha256_chain_idx_elm_t *waypoints, size_t *waypoints_length) | 
|   | function to produce a hash chain starting with a given seed element.  
  | 
|   | 
| int  | sha256_chain_verify_element (void *element, size_t element_index, void *tail_element, size_t chain_length) | 
|   | function to verify if a given chain element is part of the chain.  
  | 
|   | 
◆ SHA256_DIGEST_LENGTH
      
        
          | #define SHA256_DIGEST_LENGTH   32 | 
        
      
 
Length of SHA256 digests in bytes. 
Definition at line 61 of file sha256.h.
 
 
◆ SHA256_INTERNAL_BLOCK_SIZE
      
        
          | #define SHA256_INTERNAL_BLOCK_SIZE   (64) | 
        
      
 
512 Bit (64 Byte) internally used block size for sha256 
Definition at line 66 of file sha256.h.
 
 
◆ sha256_context_t
Context for cipher operations based on sha256. 
Definition at line 71 of file sha256.h.
 
 
◆ hmac_sha256()
      
        
          | void hmac_sha256  | 
          ( | 
          const void * |           key,  | 
        
        
           | 
           | 
          size_t |           key_length,  | 
        
        
           | 
           | 
          const void * |           data,  | 
        
        
           | 
           | 
          size_t |           len,  | 
        
        
           | 
           | 
          void * |           digest ) | 
        
      
 
function to compute a hmac-sha256 from a given message 
- Parameters
 - 
  
    | [in] | key | key used in the hmac-sha256 computation  | 
    | [in] | key_length | the size in bytes of the key  | 
    | [in] | data | pointer to the buffer to generate the hmac-sha256  | 
    | [in] | len | the length of the message in bytes  | 
    | [out] | digest | the computed hmac-sha256, length MUST be SHA256_DIGEST_LENGTH  | 
  
   
 
 
◆ hmac_sha256_final()
hmac_sha256_final HMAC SHA-256 finalization. 
Finish HMAC calculation and export the value 
- Parameters
 - 
  
    | [in] | ctx | hmac_context_t handle to use  | 
    | [out] | digest | the computed hmac-sha256, length MUST be SHA256_DIGEST_LENGTH  | 
  
   
 
 
◆ hmac_sha256_init()
      
        
          | void hmac_sha256_init  | 
          ( | 
          hmac_context_t * |           ctx,  | 
        
        
           | 
           | 
          const void * |           key,  | 
        
        
           | 
           | 
          size_t |           key_length ) | 
        
      
 
hmac_sha256_init HMAC SHA-256 calculation. 
Initiate calculation of a HMAC 
- Parameters
 - 
  
    | [in] | ctx | hmac_context_t handle to use  | 
    | [in] | key | key used in the hmac-sha256 computation  | 
    | [in] | key_length | the size in bytes of the key  | 
  
   
 
 
◆ hmac_sha256_update()
      
        
          | void hmac_sha256_update  | 
          ( | 
          hmac_context_t * |           ctx,  | 
        
        
           | 
           | 
          const void * |           data,  | 
        
        
           | 
           | 
          size_t |           len ) | 
        
      
 
hmac_sha256_update Add data bytes for HMAC calculation 
- Parameters
 - 
  
    | [in] | ctx | hmac_context_t handle to use  | 
    | [in] | data | pointer to the buffer to generate hash from  | 
    | [in] | len | length of the buffer  | 
  
   
 
 
◆ sha256()
      
        
          | void sha256  | 
          ( | 
          const void * |           data,  | 
        
        
           | 
           | 
          size_t |           len,  | 
        
        
           | 
           | 
          void * |           digest ) | 
        
      
 
A wrapper function to simplify the generation of a hash, this is useful for generating sha256 for one buffer. 
- Parameters
 - 
  
    | [in] | data | pointer to the buffer to generate hash from  | 
    | [in] | len | length of the buffer  | 
    | [out] | digest | Pointer to an array for the result, length must be SHA256_DIGEST_LENGTH  | 
  
   
 
 
◆ sha256_chain()
      
        
          | void * sha256_chain  | 
          ( | 
          const void * |           seed,  | 
        
        
           | 
           | 
          size_t |           seed_length,  | 
        
        
           | 
           | 
          size_t |           elements,  | 
        
        
           | 
           | 
          void * |           tail_element ) | 
        
      
 
function to produce a hash chain starting with a given seed element. 
The chain is computed by taking the sha256 from the seed, hash the resulting sha256 and continuing taking sha256 from each result consecutively.
- Parameters
 - 
  
    | [in] | seed | the seed of the sha256-chain, i.e. the first element  | 
    | [in] | seed_length | the size of seed in bytes  | 
    | [in] | elements | the number of chained elements, i.e. the index of the last element is (elements-1)  | 
    | [out] | tail_element | the final element of the sha256-chain | 
  
   
- Returns
 - pointer to tail_element 
 
 
 
◆ sha256_chain_verify_element()
      
        
          | int sha256_chain_verify_element  | 
          ( | 
          void * |           element,  | 
        
        
           | 
           | 
          size_t |           element_index,  | 
        
        
           | 
           | 
          void * |           tail_element,  | 
        
        
           | 
           | 
          size_t |           chain_length ) | 
        
      
 
function to verify if a given chain element is part of the chain. 
- Parameters
 - 
  
    | [in] | element | the chain element to be verified  | 
    | [in] | element_index | the position in the chain  | 
    | [in] | tail_element | the last element of the sha256-chain  | 
    | [in] | chain_length | the number of elements in the chain | 
  
   
- Returns
 - 0 if element is verified to be part of the chain at element_index 1 if the element cannot be verified as part of the chain 
 
 
 
◆ sha256_chain_with_waypoints()
      
        
          | void * sha256_chain_with_waypoints  | 
          ( | 
          const void * |           seed,  | 
        
        
           | 
           | 
          size_t |           seed_length,  | 
        
        
           | 
           | 
          size_t |           elements,  | 
        
        
           | 
           | 
          void * |           tail_element,  | 
        
        
           | 
           | 
          sha256_chain_idx_elm_t * |           waypoints,  | 
        
        
           | 
           | 
          size_t * |           waypoints_length ) | 
        
      
 
function to produce a hash chain starting with a given seed element. 
The chain is computed the same way as done with sha256_chain(). Additionally intermediate elements are saved while computing the chain. This slows down computation, but provides the caller with indexed "waypoint"-elements. They are supposed to shortcut computing verification elements, this comes in handy when using long chains, e.g. a chain with 232 elements.
- Parameters
 - 
  
    | [in] | seed | the seed of the sha256-chain, i.e. the first element  | 
    | [in] | seed_length | the size of seed in bytes  | 
    | [in] | elements | the number of chained elements, i.e. the index of the last element is (elements-1)  | 
    | [out] | tail_element | the final element of the sha256-chain  | 
    | [out] | waypoints | intermediate elements are stored there.  | 
    | [in,out] | waypoints_length | the size of the waypoints array. If the given size is equal or greater elements, the complete chain will be stored. Otherwise every n-th element is stored where: n = floor(elements / waypoints_length); floor is implicitly used since we perform unsigned integer division. The last used waypoint index is stored in the variable after call. That is (elements - 1) if the complete chain is stored, and (*waypoints_length - 1) if we only store some waypoints. | 
  
   
- Returns
 - pointer to tail_element 
 
 
 
◆ sha256_final()
SHA-256 finalization. 
Pads the input data, exports the hash value, and clears the context state.
- Parameters
 - 
  
    | ctx | sha256_context_t handle to use  | 
    | digest | resulting digest, this is the hash of all the bytes  | 
  
   
Definition at line 119 of file sha256.h.
 
 
◆ sha256_init()
SHA-256 initialization. 
Begins a SHA-256 operation.
- Parameters
 - 
  
  
 
 
 
◆ sha256_update()
  
  
      
        
          | static void sha256_update  | 
          ( | 
          sha256_context_t * |           ctx,  | 
         
        
           | 
           | 
          const void * |           data,  | 
         
        
           | 
           | 
          size_t |           len ) | 
         
       
   | 
  
inlinestatic   | 
  
 
Add bytes into the hash. 
- Parameters
 - 
  
  
 
Definition at line 107 of file sha256.h.