#include "gost_grasshopper_defines.h"
#include "gost_grasshopper_math.h"
#include "gost_grasshopper_core.h"
+#include "gost_gost2015.h"
#include <openssl/evp.h>
#include <openssl/rand.h>
};
static EVP_CIPHER *gost_grasshopper_ciphers[6] = {
- [GRASSHOPPER_CIPHER_ECB] = NULL,
- [GRASSHOPPER_CIPHER_CBC] = NULL,
- [GRASSHOPPER_CIPHER_OFB] = NULL,
- [GRASSHOPPER_CIPHER_CFB] = NULL,
- [GRASSHOPPER_CIPHER_CTR] = NULL,
- [GRASSHOPPER_CIPHER_CTRACPKM] = NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL,
};
-static GRASSHOPPER_INLINE void
-gost_grasshopper_cipher_destroy_ofb(gost_grasshopper_cipher_ctx * c);
static GRASSHOPPER_INLINE void
gost_grasshopper_cipher_destroy_ctr(gost_grasshopper_cipher_ctx * c);
};
static struct GRASSHOPPER_CIPHER_PARAMS gost_cipher_params[6] = {
- [GRASSHOPPER_CIPHER_ECB] = {
+ {
NID_grasshopper_ecb,
gost_grasshopper_cipher_init_ecb,
gost_grasshopper_cipher_do_ecb,
0,
true}
,
- [GRASSHOPPER_CIPHER_CBC] = {
+ {
NID_grasshopper_cbc,
gost_grasshopper_cipher_init_cbc,
gost_grasshopper_cipher_do_cbc,
16,
true}
,
- [GRASSHOPPER_CIPHER_OFB] = {
+ {
NID_grasshopper_ofb,
gost_grasshopper_cipher_init_ofb,
gost_grasshopper_cipher_do_ofb,
- gost_grasshopper_cipher_destroy_ofb,
+ NULL,
1,
- sizeof(gost_grasshopper_cipher_ctx_ofb),
+ sizeof(gost_grasshopper_cipher_ctx),
16,
false}
,
- [GRASSHOPPER_CIPHER_CFB] = {
+ {
NID_grasshopper_cfb,
gost_grasshopper_cipher_init_cfb,
gost_grasshopper_cipher_do_cfb,
16,
false}
,
- [GRASSHOPPER_CIPHER_CTR] = {
+ {
NID_grasshopper_ctr,
gost_grasshopper_cipher_init_ctr,
gost_grasshopper_cipher_do_ctr,
gost_grasshopper_cipher_destroy_ctr,
1,
sizeof(gost_grasshopper_cipher_ctx_ctr),
- /* IV size is set to match full block, to make it responsibility of
- * user to assign correct values (IV || 0), and to make naive context
- * copy possible (for software such as openssh) */
- 16,
+ 8,
false}
,
- [GRASSHOPPER_CIPHER_CTRACPKM] = {
- NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm,
- gost_grasshopper_cipher_init_ctracpkm,
- gost_grasshopper_cipher_do_ctracpkm,
- gost_grasshopper_cipher_destroy_ctr,
- 1,
- sizeof(gost_grasshopper_cipher_ctx_ctr),
- 16,
- false}
+ {
+ NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm,
+ gost_grasshopper_cipher_init_ctracpkm,
+ gost_grasshopper_cipher_do_ctracpkm,
+ gost_grasshopper_cipher_destroy_ctr,
+ 1,
+ sizeof(gost_grasshopper_cipher_ctx_ctr),
+ 8,
+ false}
,
};
grasshopper_zero128(&c->buffer);
}
-static GRASSHOPPER_INLINE void
-gost_grasshopper_cipher_destroy_ofb(gost_grasshopper_cipher_ctx * c)
-{
- gost_grasshopper_cipher_ctx_ofb *ctx =
- (gost_grasshopper_cipher_ctx_ofb *) c;
-
- grasshopper_zero128(&ctx->buffer1);
-}
-
static GRASSHOPPER_INLINE void
gost_grasshopper_cipher_destroy_ctr(gost_grasshopper_cipher_ctx * c)
{
*key, const unsigned char
*iv, int enc)
{
- gost_grasshopper_cipher_ctx_ofb *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
-
- c->c.type = GRASSHOPPER_CIPHER_OFB;
-
- grasshopper_zero128(&c->buffer1);
-
+ gost_grasshopper_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+ c->type = GRASSHOPPER_CIPHER_OFB;
return gost_grasshopper_cipher_init(ctx, key, iv, enc);
}
bool encrypting = (bool) EVP_CIPHER_CTX_encrypting(ctx);
const unsigned char *current_in = in;
unsigned char *current_out = out;
- grasshopper_w128_t *currentInputBlock;
- grasshopper_w128_t *currentOutputBlock;
size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
size_t i;
grasshopper_w128_t *currentBlock;
for (i = 0; i < blocks;
i++, current_in += GRASSHOPPER_BLOCK_SIZE, current_out +=
GRASSHOPPER_BLOCK_SIZE) {
- currentInputBlock = (grasshopper_w128_t *) current_in;
- currentOutputBlock = (grasshopper_w128_t *) current_out;
+ grasshopper_w128_t *currentInputBlock = (grasshopper_w128_t *) current_in;
+ grasshopper_w128_t *currentOutputBlock = (grasshopper_w128_t *) current_out;
if (encrypting) {
grasshopper_append128(currentBlock, currentInputBlock);
grasshopper_encrypt_block(&c->encrypt_round_keys, currentBlock,
void inc_counter(unsigned char *counter, size_t counter_bytes)
{
- unsigned char c;
unsigned int n = counter_bytes;
do {
+ unsigned char c;
--n;
c = counter[n];
++c;
unsigned int n = EVP_CIPHER_CTX_num(ctx);
size_t lasted;
size_t i;
+ size_t blocks;
+ grasshopper_w128_t *iv_buffer;
+ grasshopper_w128_t tmp;
while (n && inl) {
*(current_out++) = *(current_in++) ^ c->partial_buffer.b[n];
n = (n + 1) % GRASSHOPPER_BLOCK_SIZE;
}
EVP_CIPHER_CTX_set_num(ctx, n);
- size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
+ blocks = inl / GRASSHOPPER_BLOCK_SIZE;
- grasshopper_w128_t *iv_buffer = (grasshopper_w128_t *) iv;
- grasshopper_w128_t tmp;
+ iv_buffer = (grasshopper_w128_t *) iv;
// full parts
for (i = 0; i < blocks; i++) {
gost_grasshopper_cipher_ctx_ctr *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
unsigned int num = EVP_CIPHER_CTX_num(ctx);
+ size_t blocks, i, lasted;
+ grasshopper_w128_t tmp;
while ((num & GRASSHOPPER_BLOCK_MASK) && inl) {
*out++ = *in++ ^ c->partial_buffer.b[num & GRASSHOPPER_BLOCK_MASK];
--inl;
num++;
}
- size_t blocks = inl / GRASSHOPPER_BLOCK_SIZE;
- size_t i;
- grasshopper_w128_t tmp;
+ blocks = inl / GRASSHOPPER_BLOCK_SIZE;
// full parts
for (i = 0; i < blocks; i++) {
}
// last part
- size_t lasted = inl - blocks * GRASSHOPPER_BLOCK_SIZE;
+ lasted = inl - blocks * GRASSHOPPER_BLOCK_SIZE;
if (lasted > 0) {
apply_acpkm_grasshopper(c, &num);
grasshopper_encrypt_block(&c->c.encrypt_round_keys,
/*
* Fixed 128-bit IV implementation make shift regiser redundant.
*/
-static void gost_grasshopper_cnt_next(gost_grasshopper_cipher_ctx_ofb * ctx,
+static void gost_grasshopper_cnt_next(gost_grasshopper_cipher_ctx * ctx,
grasshopper_w128_t * iv,
grasshopper_w128_t * buf)
{
- memcpy(&ctx->buffer1, iv, 16);
- grasshopper_encrypt_block(&ctx->c.encrypt_round_keys, &ctx->buffer1,
- buf, &ctx->c.buffer);
+ grasshopper_w128_t tmp;
+ memcpy(&tmp, iv, 16);
+ grasshopper_encrypt_block(&ctx->encrypt_round_keys, &tmp,
+ buf, &ctx->buffer);
memcpy(iv, buf, 16);
}
int gost_grasshopper_cipher_do_ofb(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t inl)
{
- gost_grasshopper_cipher_ctx_ofb *c = (gost_grasshopper_cipher_ctx_ofb *)
+ gost_grasshopper_cipher_ctx *c = (gost_grasshopper_cipher_ctx *)
EVP_CIPHER_CTX_get_cipher_data(ctx);
const unsigned char *in_ptr = in;
unsigned char *out_ptr = out;
int gost_grasshopper_cipher_cleanup(EVP_CIPHER_CTX *ctx)
{
+ struct GRASSHOPPER_CIPHER_PARAMS *params;
gost_grasshopper_cipher_ctx *c =
(gost_grasshopper_cipher_ctx *) EVP_CIPHER_CTX_get_cipher_data(ctx);
if (!c)
return 1;
- struct GRASSHOPPER_CIPHER_PARAMS *params = &gost_cipher_params[c->type];
+ params = &gost_cipher_params[c->type];
gost_grasshopper_cipher_destroy(c);
if (params->destroy_cipher != NULL) {
int gost_grasshopper_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
{
- int len = 0;
- unsigned char *buf = NULL;
- ASN1_OCTET_STRING *os = NULL;
-
- os = ASN1_OCTET_STRING_new();
+ if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CTR_MODE) {
+ gost_grasshopper_cipher_ctx_ctr *ctr = EVP_CIPHER_CTX_get_cipher_data(ctx);
- if (!os || !ASN1_OCTET_STRING_set(os, buf, len)) {
- OPENSSL_free(buf);
- GOSTerr(GOST_F_GOST_GRASSHOPPER_SET_ASN1_PARAMETERS,
- ERR_R_MALLOC_FAILURE);
- return 0;
- }
- OPENSSL_free(buf);
-
- ASN1_TYPE_set(params, V_ASN1_SEQUENCE, os);
- return 1;
+ return gost2015_set_asn1_params(params, EVP_CIPHER_CTX_original_iv(ctx), 8,
+ ctr->kdf_seed);
+ }
+ return 0;
}
GRASSHOPPER_INLINE int gost_grasshopper_get_asn1_parameters(EVP_CIPHER_CTX
*ctx, ASN1_TYPE
*params)
{
- int ret = -1;
+ if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CTR_MODE) {
+ gost_grasshopper_cipher_ctx_ctr *ctr = EVP_CIPHER_CTX_get_cipher_data(ctx);
- if (ASN1_TYPE_get(params) != V_ASN1_SEQUENCE) {
- return ret;
- }
+ int iv_len = 16;
+ unsigned char iv[16];
- return 1;
+ if (gost2015_get_asn1_params(params, 16, iv, 8, ctr->kdf_seed) == 0) {
+ return 0;
+ }
+
+ memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, iv_len);
+ memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv, iv_len);
+
+ /* CMS implies 256kb mesh_section_size */
+ ctr->section_size = 256*1024;
+ return 1;
+ }
+ return 0;
}
int gost_grasshopper_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg,
{
switch (type) {
case EVP_CTRL_RAND_KEY:{
- if (RAND_bytes
+ if (RAND_priv_bytes
((unsigned char *)ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) {
GOSTerr(GOST_F_GOST_GRASSHOPPER_CIPHER_CTL, GOST_R_RNG_ERROR);
return -1;
unsigned char adjusted_iv[16];
unsigned char seq[8];
- int j;
+ int j, carry;
if (mode != EVP_CIPH_CTR_MODE)
return -1;
(const unsigned char *)seq) > 0) {
memset(adjusted_iv, 0, 16);
memcpy(adjusted_iv, EVP_CIPHER_CTX_original_iv(ctx), 8);
- for(j=7; j>=0; j--)
+ for(j=7,carry=0; j>=0; j--)
{
- int adj_byte, carry = 0;
- adj_byte = adjusted_iv[j]+seq[j]+carry;
+ int adj_byte = adjusted_iv[j]+seq[j]+carry;
carry = (adj_byte > 255) ? 1 : 0;
adjusted_iv[j] = adj_byte & 0xFF;
}
cipher = &gost_grasshopper_ciphers[num];
if (*cipher == NULL) {
+ grasshopper_init_cipher_func init_cipher;
+ int nid, block_size, ctx_size, iv_size;
+ bool padding;
+
params = &gost_cipher_params[num];
- int nid = params->nid;
- grasshopper_init_cipher_func init_cipher = params->init_cipher;
- int block_size = params->block_size;
- int ctx_size = params->ctx_size;
- int iv_size = params->iv_size;
- bool padding = params->padding;
+ nid = params->nid;
+ init_cipher = params->init_cipher;
+ block_size = params->block_size;
+ ctx_size = params->ctx_size;
+ iv_size = params->iv_size;
+ padding = params->padding;
*cipher = cipher_gost_grasshopper_create(nid, block_size);
if (*cipher == NULL) {
projects / openssl-gost / engine.git / blobdiff