internal.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016 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 NOISE_INTERNAL_H
#define NOISE_INTERNAL_H

#include <noise/protocol.h>
#if defined(__WIN32__) || defined(WIN32)
#include <malloc.h>
#else
#include <alloca.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#define NOISE_MAX_HASHLEN 64

#define NOISE_PSK_LEN 32

struct NoiseCipherState_s
{
    size_t size;

    int cipher_id;

    uint8_t has_key;

    uint8_t key_len;

    uint8_t mac_len;

    uint64_t n;

    NoiseCipherState *(*create)(void);

    void (*init_key)(NoiseCipherState *state, const uint8_t *key);

    int (*encrypt)(NoiseCipherState *state, const uint8_t *ad, size_t ad_len,
                   uint8_t *data, size_t len);

    int (*decrypt)(NoiseCipherState *state, const uint8_t *ad, size_t ad_len,
                   uint8_t *data, size_t len);

    void (*destroy)(NoiseCipherState *state);
};

struct NoiseHashState_s
{
    size_t size;

    int hash_id;

    uint16_t hash_len;

    uint16_t block_len;

    void (*reset)(NoiseHashState *state);

    void (*update)(NoiseHashState *state, const uint8_t *data, size_t len);

    void (*finalize)(NoiseHashState *state, uint8_t *hash);

    void (*destroy)(NoiseHashState *state);
};

/* States for public key algorithms, either DHState or SignState */
#define NOISE_KEY_TYPE_NO_KEY   0   
#define NOISE_KEY_TYPE_KEYPAIR  1   
#define NOISE_KEY_TYPE_PUBLIC   2   
struct NoiseDHState_s
{
    size_t size;

    short dh_id;

    short role;

    uint8_t key_type;

    uint8_t ephemeral_only : 1;

    uint8_t nulls_allowed : 1;

    uint16_t private_key_len;

    uint16_t public_key_len;

    uint16_t shared_key_len;

    uint8_t *private_key;

    uint8_t *public_key;

    int (*generate_keypair)(NoiseDHState *state, const NoiseDHState *other);

    int (*set_keypair)
        (NoiseDHState *state, const uint8_t *private_key,
         const uint8_t *public_key);

    int (*set_keypair_private)
        (NoiseDHState *state, const uint8_t *private_key);

    int (*validate_public_key)
        (const NoiseDHState *state, const uint8_t *public_key);

    int (*copy)(NoiseDHState *state, const NoiseDHState *from,
                const NoiseDHState *other);

    int (*calculate)
        (const NoiseDHState *private_key_state,
         const NoiseDHState *public_key_state,
         uint8_t *shared_key);

    void (*change_role)(NoiseDHState *state);

    void (*destroy)(NoiseDHState *state);
};

struct NoiseSignState_s
{
    size_t size;

    int sign_id;

    uint16_t key_type;

    uint16_t private_key_len;

    uint16_t public_key_len;

    uint16_t signature_len;

    uint8_t *private_key;

    uint8_t *public_key;

    void (*generate_keypair)(NoiseSignState *state);

    int (*validate_keypair)
        (const NoiseSignState *state, const uint8_t *private_key,
         const uint8_t *public_key);

    int (*derive_public_key)
        (const NoiseSignState *state, const uint8_t *private_key,
         uint8_t *public_key);

    int (*validate_public_key)
        (const NoiseSignState *state, const uint8_t *public_key);

    int (*sign)
        (const NoiseSignState *state, const uint8_t *message,
         size_t message_len, uint8_t *signature);

    int (*verify)
        (const NoiseSignState *state, const uint8_t *message,
         size_t message_len, const uint8_t *signature);

    void (*destroy)(NoiseSignState *state);
};

struct NoiseSymmetricState_s
{
    size_t size;

    NoiseProtocolId id;

    NoiseCipherState *cipher;

    NoiseHashState *hash;

    uint8_t ck[NOISE_MAX_HASHLEN];

    uint8_t h[NOISE_MAX_HASHLEN];
};

struct NoiseHandshakeState_s
{
    size_t size;

    int role;

    int requirements;

    int action;

    const uint8_t *tokens;

    NoiseSymmetricState *symmetric;

    NoiseDHState *dh_local_static;

    NoiseDHState *dh_local_ephemeral;

    NoiseDHState *dh_local_hybrid;

    NoiseDHState *dh_remote_static;

    NoiseDHState *dh_remote_ephemeral;

    NoiseDHState *dh_remote_hybrid;

    NoiseDHState *dh_fixed_ephemeral;

    NoiseDHState *dh_fixed_hybrid;

    uint8_t pre_shared_key[NOISE_PSK_LEN];

    size_t pre_shared_key_len;

    uint8_t *prologue;

    size_t prologue_len;
};

/* Handshake message pattern tokens (must be single-byte values) */
#define NOISE_TOKEN_END         0   
#define NOISE_TOKEN_S           1   
#define NOISE_TOKEN_E           2   
#define NOISE_TOKEN_EE          3   
#define NOISE_TOKEN_ES          4   
#define NOISE_TOKEN_SE          5   
#define NOISE_TOKEN_SS          6   
#define NOISE_TOKEN_F           7   
#define NOISE_TOKEN_FF          8   
#define NOISE_TOKEN_FLIP_DIR    255 
#define NOISE_PAT_FLAG_LOCAL_STATIC     (1 << 0)

#define NOISE_PAT_FLAG_LOCAL_EPHEMERAL  (1 << 1)

#define NOISE_PAT_FLAG_LOCAL_REQUIRED   (1 << 2)

#define NOISE_PAT_FLAG_LOCAL_EPHEM_REQ  (1 << 3)

#define NOISE_PAT_FLAG_LOCAL_HYBRID     (1 << 4)

#define NOISE_PAT_FLAG_LOCAL_HYBRID_REQ (1 << 5)

#define NOISE_PAT_FLAG_REMOTE_STATIC    (1 << 8)

#define NOISE_PAT_FLAG_REMOTE_EPHEMERAL (1 << 9)

#define NOISE_PAT_FLAG_REMOTE_REQUIRED  (1 << 10)

#define NOISE_PAT_FLAG_REMOTE_EPHEM_REQ (1 << 11) 

#define NOISE_PAT_FLAG_REMOTE_HYBRID    (1 << 12)

#define NOISE_PAT_FLAG_REMOTE_HYBRID_REQ (1 << 13)

#define NOISE_REQ_LOCAL_REQUIRED        (1 << 0)

#define NOISE_REQ_REMOTE_REQUIRED       (1 << 1)

#define NOISE_REQ_PSK                   (1 << 2)

#define NOISE_REQ_FALLBACK_PREMSG       (1 << 3)

#define NOISE_REQ_LOCAL_PREMSG          (1 << 4)

#define NOISE_REQ_REMOTE_PREMSG         (1 << 5)

#define NOISE_REQ_FALLBACK_POSSIBLE     (1 << 6)

void noise_rand_bytes(void *bytes, size_t size);

NoiseCipherState *noise_chachapoly_new(void);
NoiseCipherState *noise_aesgcm_new(void);

NoiseHashState *noise_blake2s_new(void);
NoiseHashState *noise_blake2b_new(void);
NoiseHashState *noise_sha256_new(void);
NoiseHashState *noise_sha512_new(void);

NoiseDHState *noise_curve25519_new(void);
NoiseDHState *noise_curve448_new(void);
NoiseDHState *noise_newhope_new(void);

NoiseSignState *noise_ed25519_new(void);

typedef uint16_t NoisePatternFlags_t;

const uint8_t *noise_pattern_lookup(int id);
NoisePatternFlags_t noise_pattern_reverse_flags(NoisePatternFlags_t flags);

#ifdef __cplusplus
};
#endif

#endif