denozord/strongswan-ext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved mgf1 class to libstrongswan/crypto/mgf1

Browse Source
This commit is contained in:
Andreas Steffen
2014-11-29 14:51:15 +01:00
parent 73a327404d
commit 1d3e080877
7 changed files with 51 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libstrongswan/plugins/ntru/Makefile.am
-1
View File
@@ -16,7 +16,6 @@ libstrongswan_ntru_la_SOURCES = \
ntru_convert.h ntru_convert.c \
ntru_drbg.h ntru_drbg.c \
ntru_ke.h ntru_ke.c \
ntru_mgf1.h ntru_mgf1.c \
ntru_param_set.h ntru_param_set.c \
ntru_poly.h ntru_poly.c \
ntru_public_key.h ntru_public_key.c \
src/libstrongswan/plugins/ntru/ntru_mgf1.c
-182
View File
@@ -1,182 +0,0 @@
/*
* Copyright (C) 2013 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*/
#include "ntru_mgf1.h"
#include <crypto/hashers/hasher.h>
#include <utils/debug.h>
#include <utils/test.h>
typedef struct private_ntru_mgf1_t private_ntru_mgf1_t;
/**
* Private data of an ntru_mgf1_t object.
*/
struct private_ntru_mgf1_t {
/**
* Public ntru_mgf1_t interface.
*/
ntru_mgf1_t public;
/**
* Hasher the MGF1 Mask Generation Function is based on
*/
hasher_t *hasher;
/**
* Counter
*/
u_int32_t counter;
/**
* Set if counter has reached 2^32
*/
bool overflow;
/**
* Current state to be hashed
*/
chunk_t state;
/**
* Position of the 4 octet counter string
*/
u_char *ctr_str;
};
METHOD(ntru_mgf1_t, get_hash_size, size_t,
private_ntru_mgf1_t *this)
{
return this->hasher->get_hash_size(this->hasher);
}
METHOD(ntru_mgf1_t, get_mask, bool,
private_ntru_mgf1_t *this, size_t mask_len, u_char *mask)
{
u_char buf[HASH_SIZE_SHA512];
size_t hash_len;
hash_len = this->hasher->get_hash_size(this->hasher);
while (mask_len > 0)
{
/* detect overflow, set counter string and increment counter */
if (this->overflow)
{
return FALSE;
}
htoun32(this->ctr_str, this->counter++);
if (this->counter == 0)
{
this->overflow = TRUE;
}
/* get the next or final mask block from the hash function */
if (!this->hasher->get_hash(this->hasher, this->state,
(mask_len < hash_len) ? buf : mask))
{
return FALSE;
}
if (mask_len < hash_len)
{
memcpy(mask, buf, mask_len);
return TRUE;
}
mask_len -= hash_len;
mask += hash_len;
}
return TRUE;
}
METHOD(ntru_mgf1_t, allocate_mask, bool,
private_ntru_mgf1_t *this, size_t mask_len, chunk_t *mask)
{
if (mask_len == 0)
{
*mask = chunk_empty;
return TRUE;
}
*mask = chunk_alloc(mask_len);
return get_mask(this, mask_len, mask->ptr);
}
METHOD(ntru_mgf1_t, destroy, void,
private_ntru_mgf1_t *this)
{
this->hasher->destroy(this->hasher);
chunk_clear(&this->state);
free(this);
}
/*
* Described in header.
*/
ntru_mgf1_t *ntru_mgf1_create(hash_algorithm_t alg, chunk_t seed,
bool hash_seed)
{
private_ntru_mgf1_t *this;
hasher_t *hasher;
size_t state_len;
if (seed.len == 0)
{
DBG1(DBG_LIB, "empty seed for MGF1");
return NULL;
}
hasher = lib->crypto->create_hasher(lib->crypto, alg);
if (!hasher)
{
DBG1(DBG_LIB, "failed to create %N hasher for MGF1",
hash_algorithm_names, alg);
return NULL;
}
state_len = (hash_seed ? hasher->get_hash_size(hasher) : seed.len) + 4;
INIT(this,
.public = {
.get_hash_size = _get_hash_size,
.allocate_mask = _allocate_mask,
.get_mask = _get_mask,
.destroy = _destroy,
},
.hasher = hasher,
.state = chunk_alloc(state_len),
);
/* determine position of the 4 octet counter string */
this->ctr_str = this->state.ptr + state_len - 4;
if (hash_seed)
{
if (!hasher->get_hash(hasher, seed, this->state.ptr))
{
DBG1(DBG_LIB, "failed to hash seed for MGF1");
destroy(this);
return NULL;
}
}
else
{
memcpy(this->state.ptr, seed.ptr, seed.len);
}
return &this->public;
}
EXPORT_FUNCTION_FOR_TESTS(ntru, ntru_mgf1_create);
src/libstrongswan/plugins/ntru/ntru_mgf1.h
-77
View File
@@ -1,77 +0,0 @@
/*
* Copyright (C) 2013 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*/
/**
* @defgroup ntru_mgf1 ntru_mgf1
* @{ @ingroup ntru_p
*/
#ifndef NTRU_MGF1_H_
#define NTRU_MGF1_H_
typedef struct ntru_mgf1_t ntru_mgf1_t;
#include <library.h>
/**
* Implements the PKCS#1 MGF1 Mask Generation Function based on a hash function
* defined in section 10.2.1 of RFC 2437
*/
struct ntru_mgf1_t {
/**
* Get the hash size of the underlying hash function
*
* @return hash size in bytes
*/
size_t (*get_hash_size)(ntru_mgf1_t *this);
/**
* Generate a mask pattern and copy it to an output buffer
* If the maximum number of requests has been reached, reseeding occurs
*
* @param mask_len number of mask bytes to generate
* @param mask output buffer of minimum size mask_len
* @return TRUE if successful
*/
bool (*get_mask)(ntru_mgf1_t *this, size_t mask_len, u_char *mask);
/**
* Generate a mask pattern and return it in an allocated chunk
*
* @param mask_len number of mask bytes to generate
* @param mask chunk containing generated mask
* @return TRUE if successful
*/
bool (*allocate_mask)(ntru_mgf1_t *this, size_t mask_len, chunk_t *mask);
/**
* Destroy the MGF1 object
*/
void (*destroy)(ntru_mgf1_t *this);
};
/**
* Create an MGF1 object
*
* @param alg hash algorithm to be used by MGF1
* @param seed seed used by MGF1 to generate mask from
* @param hash_seed hash seed before using it as a seed from MGF1
*/
ntru_mgf1_t *ntru_mgf1_create(hash_algorithm_t alg, chunk_t seed,
bool hash_seed);
#endif /** NTRU_MGF1_H_ @}*/
src/libstrongswan/plugins/ntru/ntru_poly.c
+3 -3
View File
@@ -16,8 +16,8 @@
*/
#include "ntru_poly.h"
#include "ntru_mgf1.h"
#include <crypto/mgf1/mgf1.h>
#include <utils/debug.h>
#include <utils/test.h>
@@ -301,10 +301,10 @@ ntru_poly_t *ntru_poly_create_from_seed(hash_algorithm_t alg, chunk_t seed,
uint8_t octets[HASH_SIZE_SHA512], *used, num_left = 0, num_needed;
uint16_t index, limit, left = 0;
int n, num_indices, index_i = 0;
ntru_mgf1_t *mgf1;
mgf1_t *mgf1;
DBG2(DBG_LIB, "MGF1 is seeded with %u bytes", seed.len);
mgf1 = ntru_mgf1_create(alg, seed, TRUE);
mgf1 = mgf1_create(alg, seed, TRUE);
if (!mgf1)
{
return NULL;
src/libstrongswan/plugins/ntru/ntru_trits.c
+4 -4
View File
@@ -1,5 +1,5 @@
/*
* Copyright (C) 2013 Andreas Steffen
* Copyright (C) 2013-2014 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program is free software; you can redistribute it and/or modify it
@@ -14,9 +14,9 @@
*/
#include "ntru_trits.h"
#include "ntru_mgf1.h"
#include "ntru_convert.h"
#include <crypto/mgf1/mgf1.h>
#include <utils/debug.h>
#include <utils/test.h>
@@ -72,10 +72,10 @@ ntru_trits_t *ntru_trits_create(size_t len, hash_algorithm_t alg, chunk_t seed)
private_ntru_trits_t *this;
uint8_t octets[HASH_SIZE_SHA512], buf[5], *trits;
size_t hash_len, octet_count = 0, trits_needed, i;
ntru_mgf1_t *mgf1;
mgf1_t *mgf1;
DBG2(DBG_LIB, "MGF1 is seeded with %u bytes", seed.len);
mgf1 = ntru_mgf1_create(alg, seed, TRUE);
mgf1 = mgf1_create(alg, seed, TRUE);
if (!mgf1)
{
return NULL;