michaelh/zephyr
1
0
Fork 0
Code Releases Activity

crypto: comply with checkpatch file length

Browse source 
Fixes the tinycrypt library to use Zephyr checkpath acceptable line
lengths.

Change-Id: Ia7bef46a39fa029cda826ec5b2d7d42036d9bdfe
Signed-off-by: Dan Kalowsky <daniel.kalowsky@intel.com>
This commit is contained in:
Dan Kalowsky 2015-10-06 15:35:12 -07:00 • committed by Anas Nashif
commit 53dbe1f1ec
21 changed files with 535 additions and 426 deletions
Download patch file Download diff file Expand all files Collapse all files

25
lib/crypto/tinycrypt/include/aes.h
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/** /**
@ -86,7 +87,9 @@ int32_t tc_aes128_set_encrypt_key(TCAesKeySched_t s, const uint8_t *k);
* @param in IN -- a plaintext block to encrypt * @param in IN -- a plaintext block to encrypt
* @param s IN -- initialized AES key schedule * @param s IN -- initialized AES key schedule
*/ */
int32_t tc_aes_encrypt(uint8_t *out, const uint8_t *in, const TCAesKeySched_t s); int32_t tc_aes_encrypt(uint8_t *out,
const uint8_t *in,
const TCAesKeySched_t s);
/** /**
* @brief Set the AES-128 decryption key * @brief Set the AES-128 decryption key
@ -115,6 +118,8 @@ int32_t tc_aes128_set_decrypt_key(TCAesKeySched_t s, const uint8_t *k);
* @param in IN -- a plaintext block to encrypt * @param in IN -- a plaintext block to encrypt
* @param s IN -- initialized AES key schedule * @param s IN -- initialized AES key schedule
*/ */
int32_t tc_aes_decrypt(uint8_t *out, const uint8_t *in, const TCAesKeySched_t s); int32_t tc_aes_decrypt(uint8_t *out,
const uint8_t *in,
const TCAesKeySched_t s);
#endif #endif

35
lib/crypto/tinycrypt/include/cbc_mode.h
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/** /**
@ -45,12 +46,12 @@
* good practice to replace the encryption when q == 2^56). CBC mode * good practice to replace the encryption when q == 2^56). CBC mode
* provides NO data integrity. * provides NO data integrity.
* *
* CBC mode assumes that the IV value input into the tc_cbc_mode_encrypt * CBC mode assumes that the IV value input into the
* is randomly generated. The TinyCrypt library provides HMAC-PRNG * tc_cbc_mode_encrypt is randomly generated. The TinyCrypt library
* module, which generates suitable IVs. Other methods for generating * provides HMAC-PRNG module, which generates suitable IVs. Other
* IVs are acceptable, provided that the values of the IVs generated * methods for generating IVs are acceptable, provided that the
* appear random to any adversary, including someone with complete * values of the IVs generated appear random to any adversary,
* knowledge of the system design. * including someone with complete knowledge of the system design.
* *
* The randomness property on which CBC mode's security depends is * The randomness property on which CBC mode's security depends is
* the unpredictability of the IV. Since it is unpredictable, this * the unpredictability of the IV. Since it is unpredictable, this
@ -103,7 +104,8 @@
* @param sched IN -- AES key schedule for this encrypt * @param sched IN -- AES key schedule for this encrypt
*/ */
int32_t tc_cbc_mode_encrypt(uint8_t *out, uint32_t outlen, const uint8_t *in, int32_t tc_cbc_mode_encrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
uint32_t inlen, const uint8_t *iv, const TCAesKeySched_t sched); uint32_t inlen, const uint8_t *iv,
const TCAesKeySched_t sched);
/** /**
* @brief CBC decryption procedure * @brief CBC decryption procedure
@ -135,6 +137,7 @@ int32_t tc_cbc_mode_encrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
* *
*/ */
int32_t tc_cbc_mode_decrypt(uint8_t *out, uint32_t outlen, const uint8_t *in, int32_t tc_cbc_mode_decrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
uint32_t inlen, const uint8_t *iv, const TCAesKeySched_t sched); uint32_t inlen, const uint8_t *iv,
const TCAesKeySched_t sched);
#endif #endif

17
lib/crypto/tinycrypt/include/ctr_mode.h
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/** /**

31
lib/crypto/tinycrypt/include/hmac.h
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/** /**
@ -65,8 +66,10 @@
#include <sha256.h> #include <sha256.h>
struct tc_hmac_state_struct { struct tc_hmac_state_struct {
struct tc_sha256_state_struct hash_state; /* the internal state required by h */ /* the internal state required by h */
uint8_t key[2*TC_SHA256_BLOCK_SIZE]; /* HMAC key schedule */ struct tc_sha256_state_struct hash_state;
/* HMAC key schedule */
uint8_t key[2*TC_SHA256_BLOCK_SIZE];
}; };
typedef struct tc_hmac_state_struct *TCHmacState_t; typedef struct tc_hmac_state_struct *TCHmacState_t;
@ -82,7 +85,9 @@ typedef struct tc_hmac_state_struct *TCHmacState_t;
* @param key IN -- the HMAC key to configure * @param key IN -- the HMAC key to configure
* @param key_size IN -- the HMAC key size * @param key_size IN -- the HMAC key size
*/ */
int32_t tc_hmac_set_key(TCHmacState_t ctx, const uint8_t *key, uint32_t key_size); int32_t tc_hmac_set_key(TCHmacState_t ctx,
const uint8_t *key,
uint32_t key_size);
/** /**
* @brief HMAC init procedure * @brief HMAC init procedure
@ -103,7 +108,9 @@ int32_t tc_hmac_init(TCHmacState_t ctx);
* @param data IN -- data to incorporate into state * @param data IN -- data to incorporate into state
* @param data_length IN -- size of data in bytes * @param data_length IN -- size of data in bytes
*/ */
int32_t tc_hmac_update(TCHmacState_t ctx, const void *data, uint32_t data_length); int32_t tc_hmac_update(TCHmacState_t ctx,
const void *data,
uint32_t data_length);
/** /**
* @brief HMAC final procedure * @brief HMAC final procedure

56
lib/crypto/tinycrypt/include/hmac_prng.h
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/** /**
@ -34,17 +35,17 @@
* @brief Interface to an HMAC-PRNG implementation. * @brief Interface to an HMAC-PRNG implementation.
* *
* Overview: A pseudo-random number generator (PRNG) generates a sequence * Overview: A pseudo-random number generator (PRNG) generates a sequence
* of numbers that have a distribution close to the one expected * of numbers that have a distribution close to the one expected
* for a sequence of truly random numbers. The NIST Special * for a sequence of truly random numbers. The NIST Special
* Publication 800-90A specifies several mechanisms to generate * Publication 800-90A specifies several mechanisms to generate
* sequences of pseudo random numbers, including the HMAC-PRNG one * sequences of pseudo random numbers, including the HMAC-PRNG one
* which is based on HMAC. TinyCrypt implements HMAC-PRNG with * which is based on HMAC. TinyCrypt implements HMAC-PRNG with
* certain modifications from the NIST SP 800-90A spec. * certain modifications from the NIST SP 800-90A spec.
* *
* Security: A cryptographically secure PRNG depends on the existence of an * Security: A cryptographically secure PRNG depends on the existence of an
* entropy source to provide a truly random seed as well as the * entropy source to provide a truly random seed as well as the
* security of the primitives used as the building blocks (HMAC and * security of the primitives used as the building blocks (HMAC and
* SHA256, for TinyCrypt). * SHA256, for TinyCrypt).
* *
* The NIST SP 800-90A standard tolerates a null personalization, * The NIST SP 800-90A standard tolerates a null personalization,
* while TinyCrypt requires a non-null personalization. This is * while TinyCrypt requires a non-null personalization. This is
@ -71,10 +72,14 @@
#include <hmac.h> #include <hmac.h>
struct tc_hmac_prng_struct { struct tc_hmac_prng_struct {
struct tc_hmac_state_struct h; /* the HMAC instance for this PRNG */ /* the HMAC instance for this PRNG */
uint8_t key[TC_SHA256_DIGEST_SIZE]; /* the PRNG key */ struct tc_hmac_state_struct h;
uint8_t v[TC_SHA256_DIGEST_SIZE]; /* PRNG state */ /* the PRNG key */
uint32_t countdown; /* calls to tc_hmac_prng_generate left before re-seed */ uint8_t key[TC_SHA256_DIGEST_SIZE];
/* PRNG state */
uint8_t v[TC_SHA256_DIGEST_SIZE];
/* calls to tc_hmac_prng_generate left before re-seed */
uint32_t countdown;
}; };
typedef struct tc_hmac_prng_struct *TCHmacPrng_t; typedef struct tc_hmac_prng_struct *TCHmacPrng_t;
@ -101,7 +106,9 @@ typedef struct tc_hmac_prng_struct *TCHmacPrng_t;
* @param personalization IN -- personalization string * @param personalization IN -- personalization string
* @param plen IN -- personalization length in bytes * @param plen IN -- personalization length in bytes
*/ */
int32_t tc_hmac_prng_init(TCHmacPrng_t prng, const uint8_t *personalization, uint32_t plen); int32_t tc_hmac_prng_init(TCHmacPrng_t prng,
const uint8_t *personalization,
uint32_t plen);
/** /**
* @brief HMAC-PRNG reseed procedure * @brief HMAC-PRNG reseed procedure
@ -123,8 +130,9 @@ int32_t tc_hmac_prng_init(TCHmacPrng_t prng, const uint8_t *personalization, uin
* @param additional_input IN -- additional input to the prng * @param additional_input IN -- additional input to the prng
* @param additionallen IN -- additional input length in bytes * @param additionallen IN -- additional input length in bytes
*/ */
int32_t tc_hmac_prng_reseed(TCHmacPrng_t prng, const uint8_t *seed, uint32_t seedlen, int32_t tc_hmac_prng_reseed(TCHmacPrng_t prng, const uint8_t *seed,
const uint8_t *additional_input, uint32_t additionallen); uint32_t seedlen, const uint8_t *additional_input,
uint32_t additionallen);
/** /**
* @brief HMAC-PRNG generate procedure * @brief HMAC-PRNG generate procedure

25
lib/crypto/tinycrypt/include/sha256.h
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/** /**
@ -42,8 +43,8 @@
* NOT behave like a random oracle, but it can be used as one if * NOT behave like a random oracle, but it can be used as one if
* the string being hashed is prefix-free encoded before hashing. * the string being hashed is prefix-free encoded before hashing.
* *
* Usage: 1) call tc_sha256_init to initialize a struct tc_sha256_state_struct * Usage: 1) call tc_sha256_init to initialize a struct
* before hashing a new string. * tc_sha256_state_struct before hashing a new string.
* *
* 2) call tc_sha256_update to hash the next string segment; * 2) call tc_sha256_update to hash the next string segment;
* tc_sha256_update can be called as many times as needed to hash * tc_sha256_update can be called as many times as needed to hash
@ -97,7 +98,9 @@ int32_t tc_sha256_init(TCSha256State_t s);
* @param data message to hash * @param data message to hash
* @param datalen length of message to hash * @param datalen length of message to hash
*/ */
int32_t tc_sha256_update(TCSha256State_t s, const uint8_t *data, size_t datalen); int32_t tc_sha256_update(TCSha256State_t s,
const uint8_t *data,
size_t datalen);
/** /**
* @brief SHA256 final procedure * @brief SHA256 final procedure

20
lib/crypto/tinycrypt/include/utils.h
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/** /**
@ -50,7 +51,8 @@
* @return returns TC_FAIL (0) if: * @return returns TC_FAIL (0) if:
* from_len > to_len. * from_len > to_len.
*/ */
uint32_t _copy(uint8_t *to, uint32_t to_len, const uint8_t *from, uint32_t from_len); uint32_t _copy(uint8_t *to, uint32_t to_len,
const uint8_t *from, uint32_t from_len);
/** /**
* @brief Set the value 'val' into the buffer 'to', 'len' times. * @brief Set the value 'val' into the buffer 'to', 'len' times.

17
lib/crypto/tinycrypt/source/aes_decrypt.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <aes.h> #include <aes.h>

20
lib/crypto/tinycrypt/source/aes_encrypt.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <aes.h> #include <aes.h>
@ -81,7 +82,8 @@ int32_t tc_aes128_set_encrypt_key(TCAesKeySched_t s, const uint8_t *k)
} }
for (i = 0; i < Nk; ++i) { for (i = 0; i < Nk; ++i) {
s->words[i] = (k[Nb*i]<<24)|(k[Nb*i+1]<<16)|(k[Nb*i+2]<<8)|(k[Nb*i+3]); s->words[i] = (k[Nb*i]<<24) | (k[Nb*i+1]<<16) |
(k[Nb*i+2]<<8) | (k[Nb*i+3]);
} }
for (; i < (Nb*(Nr+1)); ++i) { for (; i < (Nb*(Nr+1)); ++i) {

30
lib/crypto/tinycrypt/source/cbc_mode.c
View file

@ -19,21 +19,23 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <cbc_mode.h> #include <cbc_mode.h>
#include <utils.h> #include <utils.h>
int32_t tc_cbc_mode_encrypt(uint8_t *out, uint32_t outlen, const uint8_t *in, int32_t tc_cbc_mode_encrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
uint32_t inlen, const uint8_t *iv, const TCAesKeySched_t sched) uint32_t inlen, const uint8_t *iv,
const TCAesKeySched_t sched)
{ {
uint8_t buffer[TC_AES_BLOCK_SIZE]; uint8_t buffer[TC_AES_BLOCK_SIZE];
@ -61,7 +63,8 @@ int32_t tc_cbc_mode_encrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
buffer[m++] ^= *in++; buffer[m++] ^= *in++;
if (m == TC_AES_BLOCK_SIZE) { if (m == TC_AES_BLOCK_SIZE) {
(void)tc_aes_encrypt(buffer, buffer, sched); (void)tc_aes_encrypt(buffer, buffer, sched);
(void)_copy(out, TC_AES_BLOCK_SIZE, buffer, TC_AES_BLOCK_SIZE); (void)_copy(out, TC_AES_BLOCK_SIZE,
buffer, TC_AES_BLOCK_SIZE);
out += TC_AES_BLOCK_SIZE; out += TC_AES_BLOCK_SIZE;
m = 0; m = 0;
} }
@ -71,7 +74,8 @@ int32_t tc_cbc_mode_encrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
} }
int32_t tc_cbc_mode_decrypt(uint8_t *out, uint32_t outlen, const uint8_t *in, int32_t tc_cbc_mode_decrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
uint32_t inlen, const uint8_t *iv, const TCAesKeySched_t sched) uint32_t inlen, const uint8_t *iv,
const TCAesKeySched_t sched)
{ {
uint8_t buffer[TC_AES_BLOCK_SIZE]; uint8_t buffer[TC_AES_BLOCK_SIZE];
const uint8_t *p; const uint8_t *p;
@ -90,8 +94,8 @@ int32_t tc_cbc_mode_decrypt(uint8_t *out, uint32_t outlen, const uint8_t *in,
} }
/* Note that in == iv + ciphertext, i.e. the iv and the ciphertext are /* Note that in == iv + ciphertext, i.e. the iv and the ciphertext are
* contiguous. This allows for a very efficient decryption algorithm that * contiguous. This allows for a very efficient decryption algorithm
* would not otherwise be possible. */ * that would not otherwise be possible. */
p = iv; p = iv;
for (n = m = 0; n < inlen; ++n) { for (n = m = 0; n < inlen; ++n) {
if ((n % TC_AES_BLOCK_SIZE) == 0) { if ((n % TC_AES_BLOCK_SIZE) == 0) {

24
lib/crypto/tinycrypt/source/ctr_mode.c
View file

@ -19,21 +19,22 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <ctr_mode.h> #include <ctr_mode.h>
#include <utils.h> #include <utils.h>
int32_t tc_ctr_mode(uint8_t *out, uint32_t outlen, const uint8_t *in, uint32_t inlen, int32_t tc_ctr_mode(uint8_t *out, uint32_t outlen, const uint8_t *in,
uint8_t *ctr, const TCAesKeySched_t sched) uint32_t inlen, uint8_t *ctr, const TCAesKeySched_t sched)
{ {
uint8_t buffer[TC_AES_BLOCK_SIZE]; uint8_t buffer[TC_AES_BLOCK_SIZE];
@ -56,7 +57,8 @@ int32_t tc_ctr_mode(uint8_t *out, uint32_t outlen, const uint8_t *in, uint32_t i
(void)_copy(nonce, sizeof(nonce), ctr, sizeof(nonce)); (void)_copy(nonce, sizeof(nonce), ctr, sizeof(nonce));
/* select the last 4 bytes of the nonce to be incremented */ /* select the last 4 bytes of the nonce to be incremented */
block_num = (nonce[12] << 24)|(nonce[13] << 16)|(nonce[14] << 8)|(nonce[15]); block_num = (nonce[12] << 24) | (nonce[13] << 16) |
(nonce[14] << 8) | (nonce[15]);
for (i = 0; i < inlen; ++i) { for (i = 0; i < inlen; ++i) {
if ((i % (TC_AES_BLOCK_SIZE)) == 0) { if ((i % (TC_AES_BLOCK_SIZE)) == 0) {
/* encrypt data using the current nonce */ /* encrypt data using the current nonce */

55
lib/crypto/tinycrypt/source/hmac.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <hmac.h> #include <hmac.h>
@ -47,7 +48,9 @@ static void rekey(uint8_t *key, const uint8_t *new_key, uint32_t key_size)
} }
} }
int32_t tc_hmac_set_key(TCHmacState_t ctx, const uint8_t *key, uint32_t key_size) int32_t tc_hmac_set_key(TCHmacState_t ctx,
const uint8_t *key,
uint32_t key_size)
{ {
/* input sanity check: */ /* input sanity check: */
if (ctx == (TCHmacState_t) 0 || if (ctx == (TCHmacState_t) 0 ||
@ -60,12 +63,15 @@ int32_t tc_hmac_set_key(TCHmacState_t ctx, const uint8_t *key, uint32_t key_size
struct tc_hmac_state_struct dummy_state; struct tc_hmac_state_struct dummy_state;
if (key_size <= TC_SHA256_BLOCK_SIZE) { if (key_size <= TC_SHA256_BLOCK_SIZE) {
/* The next three lines consist of dummy calls just to avoid certain timing /* The next three lines consist of dummy calls just to avoid
* attacks. Without these dummy calls, adversaries would be able to learn * certain timing attacks. Without these dummy calls,
* whether the key_size is greater than TC_SHA256_BLOCK_SIZE by measuring the * adversaries would be able to learn whether the key_size is
* time consumed in this process.*/ * greater than TC_SHA256_BLOCK_SIZE by measuring the time
* consumed in this process.*/
(void)tc_sha256_init(&dummy_state.hash_state); (void)tc_sha256_init(&dummy_state.hash_state);
(void)tc_sha256_update(&dummy_state.hash_state, dummy_key, key_size); (void)tc_sha256_update(&dummy_state.hash_state,
dummy_key,
key_size);
(void)tc_sha256_final(&dummy_state.key[TC_SHA256_DIGEST_SIZE], (void)tc_sha256_final(&dummy_state.key[TC_SHA256_DIGEST_SIZE],
&dummy_state.hash_state); &dummy_state.hash_state);
@ -74,8 +80,11 @@ int32_t tc_hmac_set_key(TCHmacState_t ctx, const uint8_t *key, uint32_t key_size
} else { } else {
(void)tc_sha256_init(&ctx->hash_state); (void)tc_sha256_init(&ctx->hash_state);
(void)tc_sha256_update(&ctx->hash_state, key, key_size); (void)tc_sha256_update(&ctx->hash_state, key, key_size);
(void)tc_sha256_final(&ctx->key[TC_SHA256_DIGEST_SIZE], &ctx->hash_state); (void)tc_sha256_final(&ctx->key[TC_SHA256_DIGEST_SIZE],
rekey(ctx->key, &ctx->key[TC_SHA256_DIGEST_SIZE], TC_SHA256_DIGEST_SIZE); &ctx->hash_state);
rekey(ctx->key,
&ctx->key[TC_SHA256_DIGEST_SIZE],
TC_SHA256_DIGEST_SIZE);
} }
return TC_SUCCESS; return TC_SUCCESS;
@ -90,16 +99,19 @@ int32_t tc_hmac_init(TCHmacState_t ctx)
} }
(void)tc_sha256_init(&ctx->hash_state); (void)tc_sha256_init(&ctx->hash_state);
(void)tc_sha256_update(&ctx->hash_state, ctx->key, TC_SHA256_BLOCK_SIZE); (void)tc_sha256_update(&ctx->hash_state,
ctx->key,
TC_SHA256_BLOCK_SIZE);
return TC_SUCCESS; return TC_SUCCESS;
} }
int32_t tc_hmac_update(TCHmacState_t ctx, const void *data, uint32_t data_length) int32_t tc_hmac_update(TCHmacState_t ctx,
const void *data,
uint32_t data_length)
{ {
/* input sanity check: */ /* input sanity check: */
if (ctx == (TCHmacState_t) 0 || if (ctx == (TCHmacState_t) 0 || ctx->key == (uint8_t *) 0) {
ctx->key == (uint8_t *) 0) {
return TC_FAIL; return TC_FAIL;
} }
@ -121,7 +133,8 @@ int32_t tc_hmac_final(uint8_t *tag, uint32_t taglen, TCHmacState_t ctx)
(void) tc_sha256_final(tag, &ctx->hash_state); (void) tc_sha256_final(tag, &ctx->hash_state);
(void)tc_sha256_init(&ctx->hash_state); (void)tc_sha256_init(&ctx->hash_state);
(void)tc_sha256_update(&ctx->hash_state, &ctx->key[TC_SHA256_BLOCK_SIZE], (void)tc_sha256_update(&ctx->hash_state,
&ctx->key[TC_SHA256_BLOCK_SIZE],
TC_SHA256_BLOCK_SIZE); TC_SHA256_BLOCK_SIZE);
(void)tc_sha256_update(&ctx->hash_state, tag, TC_SHA256_DIGEST_SIZE); (void)tc_sha256_update(&ctx->hash_state, tag, TC_SHA256_DIGEST_SIZE);
(void)tc_sha256_final(tag, &ctx->hash_state); (void)tc_sha256_final(tag, &ctx->hash_state);

37
lib/crypto/tinycrypt/source/hmac_prng.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <hmac_prng.h> #include <hmac_prng.h>
@ -95,7 +96,9 @@ static void update(TCHmacPrng_t prng, const uint8_t *e, uint32_t len)
(void)tc_hmac_final(prng->v, sizeof(prng->v), &prng->h); (void)tc_hmac_final(prng->v, sizeof(prng->v), &prng->h);
} }
int32_t tc_hmac_prng_init(TCHmacPrng_t prng, const uint8_t *personalization, uint32_t plen) int32_t tc_hmac_prng_init(TCHmacPrng_t prng,
const uint8_t *personalization,
uint32_t plen)
{ {
/* input sanity check: */ /* input sanity check: */
if (prng == (TCHmacPrng_t) 0 || if (prng == (TCHmacPrng_t) 0 ||
@ -118,8 +121,11 @@ int32_t tc_hmac_prng_init(TCHmacPrng_t prng, const uint8_t *personalization, uin
return TC_SUCCESS; return TC_SUCCESS;
} }
int32_t tc_hmac_prng_reseed(TCHmacPrng_t prng, const uint8_t *seed, uint32_t seedlen, int32_t tc_hmac_prng_reseed(TCHmacPrng_t prng,
const uint8_t *additional_input, uint32_t additionallen) const uint8_t *seed,
uint32_t seedlen,
const uint8_t *additional_input,
uint32_t additionallen)
{ {
/* input sanity check: */ /* input sanity check: */
if (prng == (TCHmacPrng_t) 0 || if (prng == (TCHmacPrng_t) 0 ||
@ -130,7 +136,8 @@ int32_t tc_hmac_prng_reseed(TCHmacPrng_t prng, const uint8_t *seed, uint32_t see
} }
if (additional_input != (const uint8_t *) 0) { if (additional_input != (const uint8_t *) 0) {
/* Abort if additional_input is provided but has inappropriate length */ /* Abort if additional_input is provided but has inappropriate
* length */
if (additionallen == 0 || if (additionallen == 0 ||
additionallen > MAX_ALEN) { additionallen > MAX_ALEN) {
return TC_FAIL; return TC_FAIL;
@ -171,11 +178,13 @@ int32_t tc_hmac_prng_generate(uint8_t *out, uint32_t outlen, TCHmacPrng_t prng)
(void)tc_hmac_update(&prng->h, prng->v, sizeof(prng->v)); (void)tc_hmac_update(&prng->h, prng->v, sizeof(prng->v));
(void)tc_hmac_final(prng->v, sizeof(prng->v), &prng->h); (void)tc_hmac_final(prng->v, sizeof(prng->v), &prng->h);
bufferlen = (TC_SHA256_DIGEST_SIZE > outlen) ? outlen : TC_SHA256_DIGEST_SIZE; bufferlen = (TC_SHA256_DIGEST_SIZE > outlen) ?
outlen : TC_SHA256_DIGEST_SIZE;
(void)_copy(out, bufferlen, prng->v, bufferlen); (void)_copy(out, bufferlen, prng->v, bufferlen);
out += bufferlen; out += bufferlen;
outlen = (outlen > TC_SHA256_DIGEST_SIZE) ? (outlen - TC_SHA256_DIGEST_SIZE) : 0; outlen = (outlen > TC_SHA256_DIGEST_SIZE) ?
(outlen - TC_SHA256_DIGEST_SIZE) : 0;
} }
/* block future PRNG compromises from revealing past state */ /* block future PRNG compromises from revealing past state */

32
lib/crypto/tinycrypt/source/sha256.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <sha256.h> #include <sha256.h>
@ -42,8 +43,9 @@ int32_t tc_sha256_init(TCSha256State_t s)
} }
/* Setting the initial state values. /* Setting the initial state values.
These values correspond to the first 32 bits of the fractional parts of * These values correspond to the first 32 bits of the fractional parts
the square roots of the first 8 primes: 2, 3, 5, 7, 11, 13, 17 and 19. */ * of the square roots of the first 8 primes: 2, 3, 5, 7, 11, 13, 17
* and 19. */
_set((uint8_t *) s, 0x00, sizeof(*s)); _set((uint8_t *) s, 0x00, sizeof(*s));
s->iv[0] = 0x6a09e667; s->iv[0] = 0x6a09e667;
s->iv[1] = 0xbb67ae85; s->iv[1] = 0xbb67ae85;
@ -130,8 +132,8 @@ int32_t tc_sha256_final(uint8_t *digest, TCSha256State_t s)
} }
/* Initializing SHA-256 Hash constant words K. /* Initializing SHA-256 Hash constant words K.
These values correspond to the first 32 bits of the fractional parts of the * These values correspond to the first 32 bits of the fractional parts of the
cube roots of the first 64 primes between 2 and 311. */ * cube roots of the first 64 primes between 2 and 311. */
static const uint32_t k256[64] = { static const uint32_t k256[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@ -187,7 +189,8 @@ static void compress(uint32_t *iv, const uint8_t *data)
t1 = work_space[i] = n; t1 = work_space[i] = n;
t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i]; t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i];
t2 = Sigma0(a) + Maj(a, b, c); t2 = Sigma0(a) + Maj(a, b, c);
h = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; h = g; g = f; f = e; e = d + t1;
d = c; c = b; b = a; a = t1 + t2;
} }
for ( ; i < 64; ++i) { for ( ; i < 64; ++i) {
@ -199,7 +202,8 @@ static void compress(uint32_t *iv, const uint8_t *data)
t1 = work_space[i&0xf] += s0 + s1 + work_space[(i+9)&0xf]; t1 = work_space[i&0xf] += s0 + s1 + work_space[(i+9)&0xf];
t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i]; t1 += h + Sigma1(e) + Ch(e, f, g) + k256[i];
t2 = Sigma0(a) + Maj(a, b, c); t2 = Sigma0(a) + Maj(a, b, c);
h = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; h = g; g = f; f = e; e = d + t1;
d = c; c = b; b = a; a = t1 + t2;
} }
iv[0] += a; iv[1] += b; iv[2] += c; iv[3] += d; iv[0] += a; iv[1] += b; iv[2] += c; iv[3] += d;

23
lib/crypto/tinycrypt/source/utils.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <utils.h> #include <utils.h>
@ -36,7 +37,8 @@
#define MASK_MOST_SIG_BIT 0x80 #define MASK_MOST_SIG_BIT 0x80
#define MASK_TWENTY_SEVEN 0x1b #define MASK_TWENTY_SEVEN 0x1b
uint32_t _copy(uint8_t *to, uint32_t to_len, const uint8_t *from, uint32_t from_len) uint32_t _copy(uint8_t *to, uint32_t to_len,
const uint8_t *from, uint32_t from_len)
{ {
if (from_len <= to_len) { if (from_len <= to_len) {
(void)memcpy(to, from, from_len); (void)memcpy(to, from, from_len);
@ -56,5 +58,6 @@ void _set(uint8_t *to, uint8_t val, uint32_t len)
* the compiler won't be able to optimize */ * the compiler won't be able to optimize */
uint8_t _double_byte(uint8_t a) uint8_t _double_byte(uint8_t a)
{ {
return (a & MASK_MOST_SIG_BIT) ? ((a << 1) ^ MASK_TWENTY_SEVEN) : (a << 1); return (a & MASK_MOST_SIG_BIT) ?
((a << 1) ^ MASK_TWENTY_SEVEN) : (a << 1);
} }

38
samples/crypto/test_aes/test_aes.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/* /*
@ -82,7 +83,8 @@ uint32_t test_1(void)
struct tc_aes_key_sched_struct s; struct tc_aes_key_sched_struct s;
if (tc_aes128_set_encrypt_key(&s, nist_key) == 0) { if (tc_aes128_set_encrypt_key(&s, nist_key) == 0) {
TC_ERROR("AES128 test %s (NIST key schedule test) failed.\n", __func__); TC_ERROR("AES128 test %s (NIST key schedule test) failed.\n",
__func__);
result = TC_FAIL; result = TC_FAIL;
goto exitTest1; goto exitTest1;
} }
@ -121,12 +123,14 @@ int32_t test_2(void)
(void)tc_aes128_set_encrypt_key(&s, nist_key); (void)tc_aes128_set_encrypt_key(&s, nist_key);
if (tc_aes_encrypt(ciphertext, nist_input, &s) == 0) { if (tc_aes_encrypt(ciphertext, nist_input, &s) == 0) {
TC_ERROR("AES128 %s (NIST encryption test) failed.\n", __func__); TC_ERROR("AES128 %s (NIST encryption test) failed.\n",
__func__);
result = TC_FAIL; result = TC_FAIL;
goto exitTest2; goto exitTest2;
} }
result = check_result(2, expected, sizeof(expected), ciphertext, sizeof(ciphertext), 1); result = check_result(2, expected, sizeof(expected),
ciphertext, sizeof(ciphertext), 1);
exitTest2: exitTest2:
@ -134,20 +138,23 @@ int32_t test_2(void)
return result; return result;
} }
uint32_t var_text_test(uint32_t r, const uint8_t *in, const uint8_t *out, TCAesKeySched_t s) uint32_t var_text_test(uint32_t r, const uint8_t *in, const uint8_t *out,
TCAesKeySched_t s)
{ {
uint8_t ciphertext[NUM_OF_NIST_KEYS]; uint8_t ciphertext[NUM_OF_NIST_KEYS];
uint8_t decrypted[NUM_OF_NIST_KEYS]; uint8_t decrypted[NUM_OF_NIST_KEYS];
uint32_t result = TC_PASS; uint32_t result = TC_PASS;
(void)tc_aes_encrypt(ciphertext, in, s); (void)tc_aes_encrypt(ciphertext, in, s);
result = check_result(r, out, NUM_OF_NIST_KEYS, ciphertext, sizeof(ciphertext), 0); result = check_result(r, out, NUM_OF_NIST_KEYS,
ciphertext, sizeof(ciphertext), 0);
if (result != TC_FAIL){ if (result != TC_FAIL){
if (tc_aes_decrypt(decrypted, ciphertext, s) == 0) { if (tc_aes_decrypt(decrypted, ciphertext, s) == 0) {
TC_ERROR("aes_decrypt failed\n"); TC_ERROR("aes_decrypt failed\n");
result = TC_FAIL; result = TC_FAIL;
} else { } else {
result = check_result(r, in, NUM_OF_NIST_KEYS, decrypted, sizeof(decrypted), 0); result = check_result(r, in, NUM_OF_NIST_KEYS,
decrypted, sizeof(decrypted), 0);
} }
} }
return result; return result;
@ -1096,7 +1103,8 @@ uint32_t var_key_test(uint32_t r, const uint8_t *in, const uint8_t *out)
(void)tc_aes128_set_encrypt_key(&s, in); (void)tc_aes128_set_encrypt_key(&s, in);
(void)tc_aes_encrypt(ciphertext, plaintext, &s); (void)tc_aes_encrypt(ciphertext, plaintext, &s);
result = check_result(r, out, NUM_OF_NIST_KEYS, ciphertext, sizeof(ciphertext), 0); result = check_result(r, out, NUM_OF_NIST_KEYS,
ciphertext, sizeof(ciphertext), 0);
return result; return result;
} }

30
samples/crypto/test_cbc/test_cbc_mode.c
View file

@ -19,16 +19,16 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/* /*
DESCRIPTION DESCRIPTION
This module tests the following AES-CBC Mode routines: This module tests the following AES-CBC Mode routines:
@ -112,14 +112,17 @@ uint32_t test_1_and_2(void)
(void)memcpy(iv_buffer, iv, TC_AES_BLOCK_SIZE); (void)memcpy(iv_buffer, iv, TC_AES_BLOCK_SIZE);
TC_PRINT("CBC test #1 (encryption SP 800-38a tests):\n"); TC_PRINT("CBC test #1 (encryption SP 800-38a tests):\n");
if (tc_cbc_mode_encrypt(encrypted, sizeof(plaintext) + TC_AES_BLOCK_SIZE, if (tc_cbc_mode_encrypt(encrypted,
plaintext, sizeof(plaintext), iv_buffer, &a) == 0) { sizeof(plaintext) + TC_AES_BLOCK_SIZE,
plaintext, sizeof(plaintext),
iv_buffer, &a) == 0) {
TC_ERROR("CBC test #1 (encryption SP 800-38a tests) failed in %s.\n", __func__); TC_ERROR("CBC test #1 (encryption SP 800-38a tests) failed in %s.\n", __func__);
result = TC_FAIL; result = TC_FAIL;
goto exitTest1; goto exitTest1;
} }
result = check_result(1, ciphertext, sizeof(encrypted), encrypted, sizeof(encrypted), 1); result = check_result(1, ciphertext, sizeof(encrypted),
encrypted, sizeof(encrypted), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
TC_PRINT("CBC test #2 (decryption SP 800-38a tests):\n"); TC_PRINT("CBC test #2 (decryption SP 800-38a tests):\n");
@ -135,7 +138,8 @@ uint32_t test_1_and_2(void)
goto exitTest1; goto exitTest1;
} }
result = check_result(2, plaintext, sizeof(decrypted), decrypted, sizeof(decrypted), 1); result = check_result(2, plaintext, sizeof(decrypted),
decrypted, sizeof(decrypted), 1);
exitTest1: exitTest1:
TC_END_RESULT(result); TC_END_RESULT(result);

59
samples/crypto/test_ctr/test_ctr_mode.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/* /*
@ -50,29 +51,29 @@
uint32_t test_1_and_2(void) uint32_t test_1_and_2(void)
{ {
const uint8_t key[16] = { const uint8_t key[16] = {
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88,
0x09, 0xcf, 0x4f, 0x3c 0x09, 0xcf, 0x4f, 0x3c
}; };
uint8_t ctr[16] = { uint8_t ctr[16] = {
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
0xfc, 0xfd, 0xfe, 0xff 0xfc, 0xfd, 0xfe, 0xff
}; };
const uint8_t plaintext[64] = { const uint8_t plaintext[64] = {
0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11,
0x73, 0x93, 0x17, 0x2a, 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x73, 0x93, 0x17, 0x2a, 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51, 0x30, 0xc8, 0x1c, 0x46, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51, 0x30, 0xc8, 0x1c, 0x46,
0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b, 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b,
0xe6, 0x6c, 0x37, 0x10 0xe6, 0x6c, 0x37, 0x10
}; };
const uint8_t ciphertext[80] = { const uint8_t ciphertext[80] = {
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
0xfc, 0xfd, 0xfe, 0xff, 0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26, 0xfc, 0xfd, 0xfe, 0xff, 0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce, 0x98, 0x06, 0xf6, 0x6b, 0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce, 0x98, 0x06, 0xf6, 0x6b,
0x79, 0x70, 0xfd, 0xff, 0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff, 0x79, 0x70, 0xfd, 0xff, 0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff,
0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e, 0x5b, 0x4f, 0x09, 0x02, 0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e, 0x5b, 0x4f, 0x09, 0x02,
0x0d, 0xb0, 0x3e, 0xab, 0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1, 0x0d, 0xb0, 0x3e, 0xab, 0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1,
0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee 0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee
}; };
struct tc_aes_key_sched_struct sched; struct tc_aes_key_sched_struct sched;
uint8_t out[80]; uint8_t out[80];
@ -83,8 +84,8 @@ uint32_t test_1_and_2(void)
(void)tc_aes128_set_encrypt_key(&sched, key); (void)tc_aes128_set_encrypt_key(&sched, key);
(void)memcpy(out, ctr, sizeof(ctr)); (void)memcpy(out, ctr, sizeof(ctr));
if (tc_ctr_mode(&out[TC_AES_BLOCK_SIZE], sizeof(plaintext), plaintext, sizeof(plaintext), if (tc_ctr_mode(&out[TC_AES_BLOCK_SIZE], sizeof(plaintext), plaintext,
ctr, &sched) == 0) { sizeof(plaintext), ctr, &sched) == 0) {
TC_ERROR("CTR test #1 (encryption SP 800-38a tests) failed in %s.\n", __func__); TC_ERROR("CTR test #1 (encryption SP 800-38a tests) failed in %s.\n", __func__);
result = TC_FAIL; result = TC_FAIL;
goto exitTest1; goto exitTest1;
@ -102,7 +103,8 @@ uint32_t test_1_and_2(void)
goto exitTest1; goto exitTest1;
} }
result = check_result(2, plaintext, sizeof(plaintext), decrypted, sizeof(plaintext), 1); result = check_result(2, plaintext, sizeof(plaintext),
decrypted, sizeof(plaintext), 1);
exitTest1: exitTest1:
TC_END_RESULT(result); TC_END_RESULT(result);
@ -136,4 +138,3 @@ void main(void)
TC_END_RESULT(result); TC_END_RESULT(result);
TC_END_REPORT(result); TC_END_REPORT(result);
} }

218
samples/crypto/test_hmac/test_hmac.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/* /*
@ -40,8 +41,9 @@
#include <test_utils.h> #include <test_utils.h>
#include <hmac.h> #include <hmac.h>
uint32_t do_hmac_test(TCHmacState_t h, uint32_t testnum, const uint8_t *data, size_t datalen, uint32_t do_hmac_test(TCHmacState_t h, uint32_t testnum, const uint8_t *data,
const uint8_t *expected, size_t expectedlen) size_t datalen, const uint8_t *expected,
size_t expectedlen)
{ {
uint8_t digest[32]; uint8_t digest[32];
uint32_t result = TC_PASS; uint32_t result = TC_PASS;
@ -49,7 +51,8 @@ uint32_t do_hmac_test(TCHmacState_t h, uint32_t testnum, const uint8_t *data, si
(void)tc_hmac_init(h); (void)tc_hmac_init(h);
(void)tc_hmac_update(h, data, datalen); (void)tc_hmac_update(h, data, datalen);
(void)tc_hmac_final(digest, TC_SHA256_DIGEST_SIZE, h); (void)tc_hmac_final(digest, TC_SHA256_DIGEST_SIZE, h);
result = check_result(testnum, expected, expectedlen, digest, sizeof(digest), 1); result = check_result(testnum, expected, expectedlen,
digest, sizeof(digest), 1);
return result; return result;
} }
@ -63,22 +66,23 @@ uint32_t test_1(void)
TC_PRINT("HMAC %s:\n", __func__); TC_PRINT("HMAC %s:\n", __func__);
const uint8_t key[20] = { const uint8_t key[20] = {
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b
}; };
const uint8_t data[8] = { const uint8_t data[8] = {
0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65 0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65
}; };
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, 0x5c, 0xa8, 0xaf, 0xce, 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, 0x5c, 0xa8, 0xaf, 0xce,
0xaf, 0x0b, 0xf1, 0x2b, 0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7, 0xaf, 0x0b, 0xf1, 0x2b, 0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7 0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7
}; };
struct tc_hmac_state_struct h; struct tc_hmac_state_struct h;
(void)memset(&h, 0x00, sizeof(h)); (void)memset(&h, 0x00, sizeof(h));
(void)tc_hmac_set_key(&h, key, sizeof(key)); (void)tc_hmac_set_key(&h, key, sizeof(key));
result = do_hmac_test(&h, 1, data, sizeof(data), expected, sizeof(expected)); result = do_hmac_test(&h, 1, data, sizeof(data),
expected, sizeof(expected));
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -92,21 +96,22 @@ uint32_t test_2(void)
0x4a, 0x65, 0x66, 0x65 0x4a, 0x65, 0x66, 0x65
}; };
const uint8_t data[28] = { const uint8_t data[28] = {
0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, 0x79, 0x61, 0x20, 0x77, 0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20, 0x79, 0x61, 0x20, 0x77,
0x61, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68, 0x61, 0x6e, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
0x69, 0x6e, 0x67, 0x3f 0x69, 0x6e, 0x67, 0x3f
}; };
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, 0x6a, 0x04, 0x24, 0x26, 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e, 0x6a, 0x04, 0x24, 0x26,
0x08, 0x95, 0x75, 0xc7, 0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83, 0x08, 0x95, 0x75, 0xc7, 0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43
}; };
struct tc_hmac_state_struct h; struct tc_hmac_state_struct h;
(void)memset(&h, 0x00, sizeof(h)); (void)memset(&h, 0x00, sizeof(h));
(void)tc_hmac_set_key(&h, key, sizeof(key)); (void)tc_hmac_set_key(&h, key, sizeof(key));
result = do_hmac_test(&h, 2, data, sizeof(data), expected, sizeof(expected)); result = do_hmac_test(&h, 2, data, sizeof(data),
expected, sizeof(expected));
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -117,27 +122,28 @@ uint32_t test_3(void)
TC_PRINT("HMAC %s:\n", __func__); TC_PRINT("HMAC %s:\n", __func__);
const uint8_t key[20] = { const uint8_t key[20] = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
}; };
const uint8_t data[50] = { const uint8_t data[50] = {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd 0xdd, 0xdd
}; };
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, 0x85, 0x4d, 0xb8, 0xeb, 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46, 0x85, 0x4d, 0xb8, 0xeb,
0xd0, 0x91, 0x81, 0xa7, 0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22, 0xd0, 0x91, 0x81, 0xa7, 0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe 0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe
}; };
struct tc_hmac_state_struct h; struct tc_hmac_state_struct h;
(void)memset(&h, 0x00, sizeof(h)); (void)memset(&h, 0x00, sizeof(h));
(void)tc_hmac_set_key(&h, key, sizeof(key)); (void)tc_hmac_set_key(&h, key, sizeof(key));
result = do_hmac_test(&h, 3, data, sizeof(data), expected, sizeof(expected)); result = do_hmac_test(&h, 3, data, sizeof(data),
expected, sizeof(expected));
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -148,28 +154,29 @@ uint32_t test_4(void)
TC_PRINT("HMAC %s:\n", __func__); TC_PRINT("HMAC %s:\n", __func__);
const uint8_t key[25] = { const uint8_t key[25] = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19 0x19
}; };
const uint8_t data[50] = { const uint8_t data[50] = {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd 0xcd, 0xcd
}; };
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e, 0xa4, 0xcc, 0x81, 0x98, 0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e, 0xa4, 0xcc, 0x81, 0x98,
0x99, 0xf2, 0x08, 0x3a, 0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07, 0x99, 0xf2, 0x08, 0x3a, 0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b 0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b
}; };
struct tc_hmac_state_struct h; struct tc_hmac_state_struct h;
(void)memset(&h, 0x00, sizeof(h)); (void)memset(&h, 0x00, sizeof(h));
(void)tc_hmac_set_key(&h, key, sizeof(key)); (void)tc_hmac_set_key(&h, key, sizeof(key));
result = do_hmac_test(&h, 4, data, sizeof(data), expected, sizeof(expected)); result = do_hmac_test(&h, 4, data, sizeof(data),
expected, sizeof(expected));
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -180,24 +187,25 @@ uint32_t test_5(void)
TC_PRINT("HMAC %s:\n", __func__); TC_PRINT("HMAC %s:\n", __func__);
const uint8_t key[20] = { const uint8_t key[20] = {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c
}; };
const uint8_t data[20] = { const uint8_t data[20] = {
0x54, 0x65, 0x73, 0x74, 0x20, 0x57, 0x69, 0x74, 0x68, 0x20, 0x54, 0x72, 0x54, 0x65, 0x73, 0x74, 0x20, 0x57, 0x69, 0x74, 0x68, 0x20, 0x54, 0x72,
0x75, 0x6e, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e 0x75, 0x6e, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e
}; };
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xa3, 0xb6, 0x16, 0x74, 0x73, 0x10, 0x0e, 0xe0, 0x6e, 0x0c, 0x79, 0x6c, 0xa3, 0xb6, 0x16, 0x74, 0x73, 0x10, 0x0e, 0xe0, 0x6e, 0x0c, 0x79, 0x6c,
0x29, 0x55, 0x55, 0x2b, 0xfa, 0x6f, 0x7c, 0x0a, 0x6a, 0x8a, 0xef, 0x8b, 0x29, 0x55, 0x55, 0x2b, 0xfa, 0x6f, 0x7c, 0x0a, 0x6a, 0x8a, 0xef, 0x8b,
0x93, 0xf8, 0x60, 0xaa, 0xb0, 0xcd, 0x20, 0xc5 0x93, 0xf8, 0x60, 0xaa, 0xb0, 0xcd, 0x20, 0xc5
}; };
struct tc_hmac_state_struct h; struct tc_hmac_state_struct h;
(void)memset(&h, 0x00, sizeof(h)); (void)memset(&h, 0x00, sizeof(h));
(void)tc_hmac_set_key(&h, key, sizeof(key)); (void)tc_hmac_set_key(&h, key, sizeof(key));
result = do_hmac_test(&h, 5, data, sizeof(data), expected, sizeof(expected)); result = do_hmac_test(&h, 5, data, sizeof(data),
expected, sizeof(expected));
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -208,36 +216,37 @@ uint32_t test_6(void)
TC_PRINT("HMAC %s:\n", __func__); TC_PRINT("HMAC %s:\n", __func__);
const uint8_t key[131] = { const uint8_t key[131] = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
}; };
const uint8_t data[54] = { const uint8_t data[54] = {
0x54, 0x65, 0x73, 0x74, 0x20, 0x55, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x4c, 0x54, 0x65, 0x73, 0x74, 0x20, 0x55, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x4c,
0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x54, 0x68, 0x61, 0x6e, 0x20, 0x42, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x54, 0x68, 0x61, 0x6e, 0x20, 0x42,
0x6c, 0x6f, 0x63, 0x6b, 0x2d, 0x53, 0x69, 0x7a, 0x65, 0x20, 0x4b, 0x65, 0x6c, 0x6f, 0x63, 0x6b, 0x2d, 0x53, 0x69, 0x7a, 0x65, 0x20, 0x4b, 0x65,
0x79, 0x20, 0x2d, 0x20, 0x48, 0x61, 0x73, 0x68, 0x20, 0x4b, 0x65, 0x79, 0x79, 0x20, 0x2d, 0x20, 0x48, 0x61, 0x73, 0x68, 0x20, 0x4b, 0x65, 0x79,
0x20, 0x46, 0x69, 0x72, 0x73, 0x74 0x20, 0x46, 0x69, 0x72, 0x73, 0x74
}; };
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f, 0x0d, 0x8a, 0x26, 0xaa, 0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f, 0x0d, 0x8a, 0x26, 0xaa,
0xcb, 0xf5, 0xb7, 0x7f, 0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14, 0xcb, 0xf5, 0xb7, 0x7f, 0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54 0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54
}; };
struct tc_hmac_state_struct h; struct tc_hmac_state_struct h;
(void)memset(&h, 0x00, sizeof(h)); (void)memset(&h, 0x00, sizeof(h));
(void)tc_hmac_set_key(&h, key, sizeof(key)); (void)tc_hmac_set_key(&h, key, sizeof(key));
result = do_hmac_test(&h, 6, data, sizeof(data), expected, sizeof(expected)); result = do_hmac_test(&h, 6, data, sizeof(data),
expected, sizeof(expected));
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -248,44 +257,45 @@ uint32_t test_7(void)
TC_PRINT("HMAC %s:\n", __func__); TC_PRINT("HMAC %s:\n", __func__);
const uint8_t key[131] = { const uint8_t key[131] = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
}; };
const uint8_t data[152] = { const uint8_t data[152] = {
0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x65,
0x73, 0x74, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c, 0x73, 0x74, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c,
0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x62, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x62,
0x6c, 0x6f, 0x63, 0x6b, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x6b, 0x65, 0x6c, 0x6f, 0x63, 0x6b, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x6b, 0x65,
0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x6c, 0x61, 0x72, 0x67,
0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63,
0x6b, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x6b, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e,
0x20, 0x54, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6e, 0x65, 0x65, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6e, 0x65, 0x65,
0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x68, 0x61, 0x73, 0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x68, 0x61, 0x73,
0x68, 0x65, 0x64, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x62, 0x68, 0x65, 0x64, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x62,
0x65, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79,
0x20, 0x74, 0x68, 0x65, 0x20, 0x48, 0x4d, 0x41, 0x43, 0x20, 0x61, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x48, 0x4d, 0x41, 0x43, 0x20, 0x61, 0x6c,
0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x2e 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x2e
}; };
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb, 0x27, 0x63, 0x5f, 0xbc, 0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb, 0x27, 0x63, 0x5f, 0xbc,
0xd5, 0xb0, 0xe9, 0x44, 0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93, 0xd5, 0xb0, 0xe9, 0x44, 0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2 0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2
}; };
struct tc_hmac_state_struct h; struct tc_hmac_state_struct h;
(void)memset(&h, 0x00, sizeof(h)); (void)memset(&h, 0x00, sizeof(h));
(void)tc_hmac_set_key(&h, key, sizeof(key)); (void)tc_hmac_set_key(&h, key, sizeof(key));
result = do_hmac_test(&h, 7, data, sizeof(data), expected, sizeof(expected)); result = do_hmac_test(&h, 7, data, sizeof(data),
expected, sizeof(expected));
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }

26
samples/crypto/test_prng/test_hmac_prng.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/* /*
@ -70,12 +71,15 @@ void main(void)
seed[i] = i; seed[i] = i;
} }
/* Fake personalization and additional_input (replace by appropriate values): */ /* Fake personalization and additional_input (replace by appropriate
uint8_t *personalization = (uint8_t *) "HOSTNAME"; /* e.g.: hostname+timestamp */ * values): */
/* e.g.: hostname+timestamp */
uint8_t *personalization = (uint8_t *) "HOSTNAME";
uint8_t *additional_input = (uint8_t *) "additional input"; uint8_t *additional_input = (uint8_t *) "additional input";
TC_PRINT("HMAC-PRNG test#1 (init):\n"); TC_PRINT("HMAC-PRNG test#1 (init):\n");
if (tc_hmac_prng_init(&h, personalization, sizeof(personalization)) == 0) { if (tc_hmac_prng_init(&h, personalization,
sizeof(personalization)) == 0) {
TC_ERROR("HMAC-PRNG initialization failed.\n"); TC_ERROR("HMAC-PRNG initialization failed.\n");
result = TC_FAIL; result = TC_FAIL;
goto exitTest; goto exitTest;

143
samples/crypto/test_sha256/test_sha256.c
View file

@ -19,14 +19,15 @@
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/* /*
@ -54,9 +55,9 @@ uint32_t test_1(void)
TC_PRINT("SHA256 test #1:\n"); TC_PRINT("SHA256 test #1:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde,
0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad
}; };
const char *m = "abc"; const char *m = "abc";
uint8_t digest[32]; uint8_t digest[32];
@ -65,7 +66,8 @@ uint32_t test_1(void)
(void)tc_sha256_init(&s); (void)tc_sha256_init(&s);
tc_sha256_update(&s, (const uint8_t *) m, strlen(m)); tc_sha256_update(&s, (const uint8_t *) m, strlen(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(1, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(1, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -79,9 +81,9 @@ uint32_t test_2(void)
TC_PRINT("SHA256 test #2:\n"); TC_PRINT("SHA256 test #2:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93, 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26, 0x93,
0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1
}; };
const char *m = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; const char *m = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
uint8_t digest[32]; uint8_t digest[32];
@ -91,7 +93,8 @@ uint32_t test_2(void)
tc_sha256_update(&s, (const uint8_t *) m, strlen(m)); tc_sha256_update(&s, (const uint8_t *) m, strlen(m));
(void) tc_sha256_final(digest, &s); (void) tc_sha256_final(digest, &s);
result = check_result(2, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(2, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -102,9 +105,9 @@ uint32_t test_3(void)
TC_PRINT("SHA256 test #3:\n"); TC_PRINT("SHA256 test #3:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b,
0x31, 0x3d, 0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0x31, 0x3d, 0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa,
0xe1, 0x12, 0x04, 0xc0, 0x8f, 0xfe, 0x73, 0x2b 0xe1, 0x12, 0x04, 0xc0, 0x8f, 0xfe, 0x73, 0x2b
}; };
const uint8_t m[1] = { 0xbd }; const uint8_t m[1] = { 0xbd };
uint8_t digest[32]; uint8_t digest[32];
@ -114,7 +117,8 @@ uint32_t test_3(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(3, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(3, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -125,9 +129,9 @@ uint32_t test_4(void)
TC_PRINT("SHA256 test #4:\n"); TC_PRINT("SHA256 test #4:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x7a, 0xbc, 0x22, 0xc0, 0xae, 0x5a, 0xf2, 0x6c, 0xe9, 0x3d, 0xbb, 0x94, 0x7a, 0xbc, 0x22, 0xc0, 0xae, 0x5a, 0xf2, 0x6c, 0xe9, 0x3d, 0xbb, 0x94,
0x43, 0x3a, 0x0e, 0x0b, 0x2e, 0x11, 0x9d, 0x01, 0x4f, 0x8e, 0x7f, 0x65, 0x43, 0x3a, 0x0e, 0x0b, 0x2e, 0x11, 0x9d, 0x01, 0x4f, 0x8e, 0x7f, 0x65,
0xbd, 0x56, 0xc6, 0x1c, 0xcc, 0xcd, 0x95, 0x04 0xbd, 0x56, 0xc6, 0x1c, 0xcc, 0xcd, 0x95, 0x04
}; };
const uint8_t m[4] = { 0xc9, 0x8c, 0x8e, 0x55 }; const uint8_t m[4] = { 0xc9, 0x8c, 0x8e, 0x55 };
uint8_t digest[32]; uint8_t digest[32];
@ -137,7 +141,8 @@ uint32_t test_4(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(4, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(4, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -148,9 +153,9 @@ uint32_t test_5(void)
TC_PRINT("SHA256 test #5:\n"); TC_PRINT("SHA256 test #5:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x02, 0x77, 0x94, 0x66, 0xcd, 0xec, 0x16, 0x38, 0x11, 0xd0, 0x78, 0x81, 0x02, 0x77, 0x94, 0x66, 0xcd, 0xec, 0x16, 0x38, 0x11, 0xd0, 0x78, 0x81,
0x5c, 0x63, 0x3f, 0x21, 0x90, 0x14, 0x13, 0x08, 0x14, 0x49, 0x00, 0x2f, 0x5c, 0x63, 0x3f, 0x21, 0x90, 0x14, 0x13, 0x08, 0x14, 0x49, 0x00, 0x2f,
0x24, 0xaa, 0x3e, 0x80, 0xf0, 0xb8, 0x8e, 0xf7 0x24, 0xaa, 0x3e, 0x80, 0xf0, 0xb8, 0x8e, 0xf7
}; };
uint8_t m[55]; uint8_t m[55];
uint8_t digest[32]; uint8_t digest[32];
@ -162,7 +167,8 @@ uint32_t test_5(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(5, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(5, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -173,9 +179,9 @@ uint32_t test_6(void)
TC_PRINT("SHA256 test #6:\n"); TC_PRINT("SHA256 test #6:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xd4, 0x81, 0x7a, 0xa5, 0x49, 0x76, 0x28, 0xe7, 0xc7, 0x7e, 0x6b, 0x60, 0xd4, 0x81, 0x7a, 0xa5, 0x49, 0x76, 0x28, 0xe7, 0xc7, 0x7e, 0x6b, 0x60,
0x61, 0x07, 0x04, 0x2b, 0xbb, 0xa3, 0x13, 0x08, 0x88, 0xc5, 0xf4, 0x7a, 0x61, 0x07, 0x04, 0x2b, 0xbb, 0xa3, 0x13, 0x08, 0x88, 0xc5, 0xf4, 0x7a,
0x37, 0x5e, 0x61, 0x79, 0xbe, 0x78, 0x9f, 0xbb 0x37, 0x5e, 0x61, 0x79, 0xbe, 0x78, 0x9f, 0xbb
}; };
uint8_t m[56]; uint8_t m[56];
uint8_t digest[32]; uint8_t digest[32];
@ -187,7 +193,8 @@ uint32_t test_6(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(6, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(6, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -198,9 +205,9 @@ uint32_t test_7(void)
TC_PRINT("SHA256 test #7:\n"); TC_PRINT("SHA256 test #7:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x65, 0xa1, 0x6c, 0xb7, 0x86, 0x13, 0x35, 0xd5, 0xac, 0xe3, 0xc6, 0x07, 0x65, 0xa1, 0x6c, 0xb7, 0x86, 0x13, 0x35, 0xd5, 0xac, 0xe3, 0xc6, 0x07,
0x18, 0xb5, 0x05, 0x2e, 0x44, 0x66, 0x07, 0x26, 0xda, 0x4c, 0xd1, 0x3b, 0x18, 0xb5, 0x05, 0x2e, 0x44, 0x66, 0x07, 0x26, 0xda, 0x4c, 0xd1, 0x3b,
0xb7, 0x45, 0x38, 0x1b, 0x23, 0x5a, 0x17, 0x85 0xb7, 0x45, 0x38, 0x1b, 0x23, 0x5a, 0x17, 0x85
}; };
uint8_t m[57]; uint8_t m[57];
uint8_t digest[32]; uint8_t digest[32];
@ -212,7 +219,8 @@ uint32_t test_7(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(7, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(7, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -223,9 +231,9 @@ uint32_t test_8(void)
TC_PRINT("SHA256 test #8:\n"); TC_PRINT("SHA256 test #8:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xf5, 0xa5, 0xfd, 0x42, 0xd1, 0x6a, 0x20, 0x30, 0x27, 0x98, 0xef, 0x6e, 0xf5, 0xa5, 0xfd, 0x42, 0xd1, 0x6a, 0x20, 0x30, 0x27, 0x98, 0xef, 0x6e,
0xd3, 0x09, 0x97, 0x9b, 0x43, 0x00, 0x3d, 0x23, 0x20, 0xd9, 0xf0, 0xe8, 0xd3, 0x09, 0x97, 0x9b, 0x43, 0x00, 0x3d, 0x23, 0x20, 0xd9, 0xf0, 0xe8,
0xea, 0x98, 0x31, 0xa9, 0x27, 0x59, 0xfb, 0x4b 0xea, 0x98, 0x31, 0xa9, 0x27, 0x59, 0xfb, 0x4b
}; };
uint8_t m[64]; uint8_t m[64];
uint8_t digest[32]; uint8_t digest[32];
@ -237,7 +245,8 @@ uint32_t test_8(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(8, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(8, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -248,9 +257,9 @@ uint32_t test_9(void)
TC_PRINT("SHA256 test #9:\n"); TC_PRINT("SHA256 test #9:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x54, 0x1b, 0x3e, 0x9d, 0xaa, 0x09, 0xb2, 0x0b, 0xf8, 0x5f, 0xa2, 0x73, 0x54, 0x1b, 0x3e, 0x9d, 0xaa, 0x09, 0xb2, 0x0b, 0xf8, 0x5f, 0xa2, 0x73,
0xe5, 0xcb, 0xd3, 0xe8, 0x01, 0x85, 0xaa, 0x4e, 0xc2, 0x98, 0xe7, 0x65, 0xe5, 0xcb, 0xd3, 0xe8, 0x01, 0x85, 0xaa, 0x4e, 0xc2, 0x98, 0xe7, 0x65,
0xdb, 0x87, 0x74, 0x2b, 0x70, 0x13, 0x8a, 0x53 0xdb, 0x87, 0x74, 0x2b, 0x70, 0x13, 0x8a, 0x53
}; };
uint8_t m[1000]; uint8_t m[1000];
uint8_t digest[32]; uint8_t digest[32];
@ -262,7 +271,8 @@ uint32_t test_9(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(9, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(9, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -273,9 +283,9 @@ uint32_t test_10(void)
TC_PRINT("SHA256 test #10:\n"); TC_PRINT("SHA256 test #10:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xc2, 0xe6, 0x86, 0x82, 0x34, 0x89, 0xce, 0xd2, 0x01, 0x7f, 0x60, 0x59, 0xc2, 0xe6, 0x86, 0x82, 0x34, 0x89, 0xce, 0xd2, 0x01, 0x7f, 0x60, 0x59,
0xb8, 0xb2, 0x39, 0x31, 0x8b, 0x63, 0x64, 0xf6, 0xdc, 0xd8, 0x35, 0xd0, 0xb8, 0xb2, 0x39, 0x31, 0x8b, 0x63, 0x64, 0xf6, 0xdc, 0xd8, 0x35, 0xd0,
0xa5, 0x19, 0x10, 0x5a, 0x1e, 0xad, 0xd6, 0xe4 0xa5, 0x19, 0x10, 0x5a, 0x1e, 0xad, 0xd6, 0xe4
}; };
uint8_t m[1000]; uint8_t m[1000];
uint8_t digest[32]; uint8_t digest[32];
@ -287,7 +297,8 @@ uint32_t test_10(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(10, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(10, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -298,9 +309,9 @@ uint32_t test_11(void)
TC_PRINT("SHA256 test #11:\n"); TC_PRINT("SHA256 test #11:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xf4, 0xd6, 0x2d, 0xde, 0xc0, 0xf3, 0xdd, 0x90, 0xea, 0x13, 0x80, 0xfa, 0xf4, 0xd6, 0x2d, 0xde, 0xc0, 0xf3, 0xdd, 0x90, 0xea, 0x13, 0x80, 0xfa,
0x16, 0xa5, 0xff, 0x8d, 0xc4, 0xc5, 0x4b, 0x21, 0x74, 0x06, 0x50, 0xf2, 0x16, 0xa5, 0xff, 0x8d, 0xc4, 0xc5, 0x4b, 0x21, 0x74, 0x06, 0x50, 0xf2,
0x4a, 0xfc, 0x41, 0x20, 0x90, 0x35, 0x52, 0xb0 0x4a, 0xfc, 0x41, 0x20, 0x90, 0x35, 0x52, 0xb0
}; };
uint8_t m[1005]; uint8_t m[1005];
uint8_t digest[32]; uint8_t digest[32];
@ -312,7 +323,8 @@ uint32_t test_11(void)
tc_sha256_update(&s, m, sizeof(m)); tc_sha256_update(&s, m, sizeof(m));
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(11, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(11, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -323,9 +335,9 @@ uint32_t test_12(void)
TC_PRINT("SHA256 test #12:\n"); TC_PRINT("SHA256 test #12:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0xd2, 0x97, 0x51, 0xf2, 0x64, 0x9b, 0x32, 0xff, 0x57, 0x2b, 0x5e, 0x0a, 0xd2, 0x97, 0x51, 0xf2, 0x64, 0x9b, 0x32, 0xff, 0x57, 0x2b, 0x5e, 0x0a,
0x9f, 0x54, 0x1e, 0xa6, 0x60, 0xa5, 0x0f, 0x94, 0xff, 0x0b, 0xee, 0xdf, 0x9f, 0x54, 0x1e, 0xa6, 0x60, 0xa5, 0x0f, 0x94, 0xff, 0x0b, 0xee, 0xdf,
0xb0, 0xb6, 0x92, 0xb9, 0x24, 0xcc, 0x80, 0x25 0xb0, 0xb6, 0x92, 0xb9, 0x24, 0xcc, 0x80, 0x25
}; };
uint8_t m[1000]; uint8_t m[1000];
uint8_t digest[32]; uint8_t digest[32];
@ -340,7 +352,8 @@ uint32_t test_12(void)
} }
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(12, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(12, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -351,9 +364,9 @@ uint32_t test_13(void)
TC_PRINT("SHA256 test #13:\n"); TC_PRINT("SHA256 test #13:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x15, 0xa1, 0x86, 0x8c, 0x12, 0xcc, 0x53, 0x95, 0x1e, 0x18, 0x23, 0x44, 0x15, 0xa1, 0x86, 0x8c, 0x12, 0xcc, 0x53, 0x95, 0x1e, 0x18, 0x23, 0x44,
0x27, 0x74, 0x47, 0xcd, 0x09, 0x79, 0x53, 0x6b, 0xad, 0xcc, 0x51, 0x2a, 0x27, 0x74, 0x47, 0xcd, 0x09, 0x79, 0x53, 0x6b, 0xad, 0xcc, 0x51, 0x2a,
0xd2, 0x4c, 0x67, 0xe9, 0xb2, 0xd4, 0xf3, 0xdd 0xd2, 0x4c, 0x67, 0xe9, 0xb2, 0xd4, 0xf3, 0xdd
}; };
uint8_t m[32768]; uint8_t m[32768];
uint8_t digest[32]; uint8_t digest[32];
@ -368,7 +381,8 @@ uint32_t test_13(void)
} }
(void)tc_sha256_final(digest, &s); (void)tc_sha256_final(digest, &s);
result = check_result(13, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(13, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }
@ -379,9 +393,9 @@ uint32_t test_14(void)
TC_PRINT("SHA256 test #14:\n"); TC_PRINT("SHA256 test #14:\n");
const uint8_t expected[32] = { const uint8_t expected[32] = {
0x46, 0x1c, 0x19, 0xa9, 0x3b, 0xd4, 0x34, 0x4f, 0x92, 0x15, 0xf5, 0xec, 0x46, 0x1c, 0x19, 0xa9, 0x3b, 0xd4, 0x34, 0x4f, 0x92, 0x15, 0xf5, 0xec,
0x64, 0x35, 0x70, 0x90, 0x34, 0x2b, 0xc6, 0x6b, 0x15, 0xa1, 0x48, 0x31, 0x64, 0x35, 0x70, 0x90, 0x34, 0x2b, 0xc6, 0x6b, 0x15, 0xa1, 0x48, 0x31,
0x7d, 0x27, 0x6e, 0x31, 0xcb, 0xc2, 0x0b, 0x53 0x7d, 0x27, 0x6e, 0x31, 0xcb, 0xc2, 0x0b, 0x53
}; };
uint8_t m[32768]; uint8_t m[32768];
uint8_t digest[32]; uint8_t digest[32];
@ -396,7 +410,8 @@ uint32_t test_14(void)
} }
(void) tc_sha256_final(digest, &s); (void) tc_sha256_final(digest, &s);
result = check_result(14, expected, sizeof(expected), digest, sizeof(digest), 1); result = check_result(14, expected, sizeof(expected),
digest, sizeof(digest), 1);
TC_END_RESULT(result); TC_END_RESULT(result);
return result; return result;
} }