ascon-masked-word.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 Southern Storm Software, Pty Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef ASCON_MASKED_WORD_H
#define ASCON_MASKED_WORD_H
 
#include <ascon/masking.h>
#include "ascon-masked-backend.h"
#include "random/ascon-trng.h"
#include "core/ascon-util.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef union
{
    uint64_t S[ASCON_MASKED_MAX_SHARES];
 
    uint32_t W[ASCON_MASKED_MAX_SHARES * 2];
 
    uint8_t B[ASCON_MASKED_MAX_SHARES * 8];
 
} ascon_masked_word_t;
 
#if !defined(ASCON_MASKED_WORD_BACKEND_DIRECT_XOR)
 
#define ascon_mask64_rotate_share1_0(x) (rightRotate11_64((x)))
 
#define ascon_mask64_rotate_share2_0(x) (rightRotate22_64((x)))
 
#define ascon_mask64_rotate_share2_1(x) (rightRotate11_64((x)))
 
#define ascon_mask64_rotate_share3_0(x) (rightRotate33_64((x)))
 
#define ascon_mask64_rotate_share3_1(x) (rightRotate22_64((x)))
 
#define ascon_mask64_rotate_share3_2(x) (rightRotate11_64((x)))
 
#define ascon_mask64_unrotate_share1_0(x) (rightRotate53_64((x)))
 
#define ascon_mask64_unrotate_share2_0(x) (rightRotate42_64((x)))
 
#define ascon_mask64_unrotate_share2_1(x) (rightRotate53_64((x)))
 
#define ascon_mask64_unrotate_share3_0(x) (rightRotate31_64((x)))
 
#define ascon_mask64_unrotate_share3_1(x) (rightRotate42_64((x)))
 
#define ascon_mask64_unrotate_share3_2(x) (rightRotate53_64((x)))
 
#define ascon_mask32_rotate_share1_0(x) (rightRotate5((x)))
 
#define ascon_mask32_rotate_share2_0(x) (rightRotate10((x)))
 
#define ascon_mask32_rotate_share2_1(x) (rightRotate5((x)))
 
#define ascon_mask32_rotate_share3_0(x) (rightRotate15((x)))
 
#define ascon_mask32_rotate_share3_1(x) (rightRotate10((x)))
 
#define ascon_mask32_rotate_share3_2(x) (rightRotate5((x)))
 
#define ascon_mask32_unrotate_share1_0(x) (rightRotate27((x)))
 
#define ascon_mask32_unrotate_share2_0(x) (rightRotate22((x)))
 
#define ascon_mask32_unrotate_share2_1(x) (rightRotate27((x)))
 
#define ascon_mask32_unrotate_share3_0(x) (rightRotate17((x)))
 
#define ascon_mask32_unrotate_share3_1(x) (rightRotate22((x)))
 
#define ascon_mask32_unrotate_share3_2(x) (rightRotate27((x)))
 
#else /* ASCON_MASKED_WORD_BACKEND_DIRECT_XOR */
 
/* Direct XOR masking method does not rotate the shares */
#define ascon_mask64_rotate_share1_0(x)   (x)
#define ascon_mask64_rotate_share2_0(x)   (x)
#define ascon_mask64_rotate_share2_1(x)   (x)
#define ascon_mask64_rotate_share3_0(x)   (x)
#define ascon_mask64_rotate_share3_1(x)   (x)
#define ascon_mask64_rotate_share3_2(x)   (x)
#define ascon_mask64_unrotate_share1_0(x) (x)
#define ascon_mask64_unrotate_share2_0(x) (x)
#define ascon_mask64_unrotate_share2_1(x) (x)
#define ascon_mask64_unrotate_share3_0(x) (x)
#define ascon_mask64_unrotate_share3_1(x) (x)
#define ascon_mask64_unrotate_share3_2(x) (x)
#define ascon_mask32_rotate_share1_0(x)   (x)
#define ascon_mask32_rotate_share2_0(x)   (x)
#define ascon_mask32_rotate_share2_1(x)   (x)
#define ascon_mask32_rotate_share3_0(x)   (x)
#define ascon_mask32_rotate_share3_1(x)   (x)
#define ascon_mask32_rotate_share3_2(x)   (x)
#define ascon_mask32_unrotate_share1_0(x) (x)
#define ascon_mask32_unrotate_share2_0(x) (x)
#define ascon_mask32_unrotate_share2_1(x) (x)
#define ascon_mask32_unrotate_share3_0(x) (x)
#define ascon_mask32_unrotate_share3_1(x) (x)
#define ascon_mask32_unrotate_share3_2(x) (x)
 
#endif /* ASCON_MASKED_WORD_BACKEND_DIRECT_XOR */
 
void ascon_masked_word_x2_zero
    (ascon_masked_word_t *word, ascon_trng_state_t *trng);
 
void ascon_masked_word_x2_load
    (ascon_masked_word_t *word, const uint8_t *data,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x2_load_partial
    (ascon_masked_word_t *word, const uint8_t *data, unsigned size,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x2_load_32
    (ascon_masked_word_t *word, const uint8_t *data1,
     const uint8_t *data2, ascon_trng_state_t *trng);
 
void ascon_masked_word_x2_store
    (uint8_t *data, const ascon_masked_word_t *word);
 
void ascon_masked_word_x2_store_partial
    (uint8_t *data, unsigned size, const ascon_masked_word_t *word);
 
void ascon_masked_word_x2_randomize
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x2_xor
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src);
 
void ascon_masked_word_x2_replace
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src, unsigned size);
 
void ascon_masked_word_x2_from_x3
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x2_from_x4
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x3_zero
    (ascon_masked_word_t *word, ascon_trng_state_t *trng);
 
void ascon_masked_word_x3_load
    (ascon_masked_word_t *word, const uint8_t *data,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x3_load_partial
    (ascon_masked_word_t *word, const uint8_t *data, unsigned size,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x3_load_32
    (ascon_masked_word_t *word, const uint8_t *data1,
     const uint8_t *data2, ascon_trng_state_t *trng);
 
void ascon_masked_word_x3_store
    (uint8_t *data, const ascon_masked_word_t *word);
 
void ascon_masked_word_x3_store_partial
    (uint8_t *data, unsigned size, const ascon_masked_word_t *word);
 
void ascon_masked_word_x3_randomize
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x3_xor
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src);
 
void ascon_masked_word_x3_replace
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src, unsigned size);
 
void ascon_masked_word_x3_from_x2
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x3_from_x4
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x4_zero
    (ascon_masked_word_t *word, ascon_trng_state_t *trng);
 
void ascon_masked_word_x4_load
    (ascon_masked_word_t *word, const uint8_t *data,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x4_load_partial
    (ascon_masked_word_t *word, const uint8_t *data, unsigned size,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x4_load_32
    (ascon_masked_word_t *word, const uint8_t *data1,
     const uint8_t *data2, ascon_trng_state_t *trng);
 
void ascon_masked_word_x4_store
    (uint8_t *data, const ascon_masked_word_t *word);
 
void ascon_masked_word_x4_store_partial
    (uint8_t *data, unsigned size, const ascon_masked_word_t *word);
 
void ascon_masked_word_x4_randomize
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x4_xor
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src);
 
void ascon_masked_word_x4_replace
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src, unsigned size);
 
void ascon_masked_word_x4_from_x2
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_x4_from_x3
    (ascon_masked_word_t *dest, const ascon_masked_word_t *src,
     ascon_trng_state_t *trng);
 
void ascon_masked_word_pad(ascon_masked_word_t *word, unsigned offset);
 
void ascon_masked_word_separator(ascon_masked_word_t *word);
 
#ifdef __cplusplus
}
#endif
 
#endif