abc/GmSSL
1
0
Fork 0
mirror of https://github.com/guanzhi/GmSSL.git synced 2026-05-12 19:36:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

tls 1.3 init

Browse Source
This commit is contained in:
Zhi Guan
2021-07-28 16:32:10 +08:00
parent ce7dd7fccf
commit 62d1899760
66 changed files with 3080 additions and 18101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
src/block_cipher.c
View File

@@ -52,152 +52,68 @@
#include <stdlib.h>
#include <gmssl/oid.h>
#include <gmssl/block_cipher.h>
#include "internal/endian.h"
#include "endian.h"
int block_cipher_encrypt_init(BLOCK_CIPHER_KEY *key, const BLOCK_CIPHER *cipher,
const uint8_t *user_key, size_t keylen)
int block_cipher_set_encrypt_key(BLOCK_CIPHER_KEY *key, const BLOCK_CIPHER *cipher, const uint8_t *raw_key)
{
memset(key, 0, sizeof(BLOCK_CIPHER_KEY));
cipher->set_encrypt_key(key, raw_key);
key->cipher = cipher;
return key->cipher->set_encrypt_key(key, user_key, keylen);
}
int block_cipher_decrypt_init(BLOCK_CIPHER_KEY *key, const BLOCK_CIPHER *cipher,
const uint8_t *user_key, size_t keylen)
{
memset(key, 0, sizeof(BLOCK_CIPHER_KEY));
key->cipher = cipher;
return key->cipher->set_decrypt_key(key, user_key, keylen);
}
void block_cipher_encrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *in, uint8_t *out)
{
key->cipher->encrypt(key, in, out);
}
void block_cipher_decrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *in, uint8_t *out)
{
key->cipher->decrypt(key, in, out);
}
void block_cipher_ecb_encrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *in, size_t nblocks, uint8_t *out)
{
while (nblocks--) {
key->cipher->encrypt(key, in, out);
in += key->cipher->block_size;
out += key->cipher->block_size;
}
}
void block_cipher_ecb_decrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *in, size_t nblocks, uint8_t *out)
{
while (nblocks--) {
key->cipher->decrypt(key, in, out);
in += key->cipher->block_size;
out += key->cipher->block_size;
}
}
void block_cipher_cbc_encrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *iv,
const uint8_t *in, size_t nblocks, uint8_t *out)
{
while (nblocks--) {
gmssl_memxor(out, in, iv, key->cipher->block_size);
key->cipher->encrypt(key, out, out);
iv = out;
in += key->cipher->block_size;
out += key->cipher->block_size;
}
}
void block_cipher_cbc_decrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *iv,
const uint8_t *in, size_t nblocks, uint8_t *out)
{
while (nblocks--) {
key->cipher->decrypt(key, in, out);
gmssl_memxor(out, out, iv, key->cipher->block_size);
iv = in;
in += key->cipher->block_size;
out += key->cipher->block_size;
}
}
void block_cipher_ctr_encrypt(const BLOCK_CIPHER_KEY *key, uint8_t *counter,
const uint8_t *in, size_t nblocks, uint8_t *out)
{
size_t block_size = key->cipher->block_size;
uint8_t block[block_size];
uint64_t ctr = GETU64(counter + block_size - sizeof(uint64_t));
while (nblocks--) {
key->cipher->encrypt(key, counter, block);
gmssl_memxor(out, in, block, block_size);
in += block_size;
out += block_size;
ctr++;
PUTU64(counter + block_size - sizeof(uint64_t), ctr);
}
}
static const BLOCK_CIPHER aes_block_cipher_object = {
OID_aes,
AES128_KEY_SIZE,
AES256_KEY_SIZE,
AES_BLOCK_SIZE,
(block_cipher_set_encrypt_key_func)aes_set_encrypt_key,
(block_cipher_set_decrypt_key_func)aes_set_decrypt_key,
(block_cipher_encrypt_func)aes_encrypt,
(block_cipher_decrypt_func)aes_encrypt,
};
const BLOCK_CIPHER *BLOCK_CIPHER_aes(void)
{
return &aes_block_cipher_object;
}
static int set_encrypt_key(BLOCK_CIPHER_KEY *key, const uint8_t *user_key, size_t keylen)
{
if (keylen != SM4_KEY_SIZE) {
return -1;
}
sm4_set_encrypt_key(&key->u.sm4_key, user_key);
return 1;
}
static int set_decrypt_key(BLOCK_CIPHER_KEY *key, const uint8_t *user_key, size_t keylen)
int block_cipher_set_decrypt_key(BLOCK_CIPHER_KEY *key, const BLOCK_CIPHER *cipher, const uint8_t *raw_key)
{
if (keylen != SM4_KEY_SIZE) {
return -1;
}
sm4_set_decrypt_key(&key->u.sm4_key, user_key);
memset(key, 0, sizeof(BLOCK_CIPHER_KEY));
cipher->set_decrypt_key(key, raw_key);
key->cipher = cipher;
return 1;
}
int block_cipher_encrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *in, uint8_t *out)
{
key->cipher->encrypt(key, in, out);
return 1;
}
int block_cipher_decrypt(const BLOCK_CIPHER_KEY *key, const uint8_t *in, uint8_t *out)
{
key->cipher->decrypt(key, in, out);
return 1;
}
static const BLOCK_CIPHER sm4_block_cipher_object = {
OID_sm4,
SM4_KEY_SIZE,
SM4_KEY_SIZE,
SM4_BLOCK_SIZE,
set_encrypt_key,
set_decrypt_key,
(block_cipher_set_encrypt_key_func)sm4_set_encrypt_key,
(block_cipher_set_decrypt_key_func)sm4_set_decrypt_key,
(block_cipher_encrypt_func)sm4_encrypt,
(block_cipher_decrypt_func)sm4_encrypt,
};
const BLOCK_CIPHER *BLOCK_CIPHER_sm4(void)
{
const BLOCK_CIPHER *BLOCK_CIPHER_sm4(void) {
return &sm4_block_cipher_object;
}
const BLOKC_CIPHER *block_cipher_from_name(const char *name)
{
if (strcmp(name, "aes") == 0) {
return BLOCK_CIPHER_aes();
} else if (strcmp(name, "sm4") == 0) {
return BLOCK_CIPHER_sm4();
}
return NULL;
static int aes128_set_encrypt_key(AES_KEY *aes_key, const uint8_t key[16]) {
return aes_set_encrypt_key(aes_key, key, 16);
}
static int aes128_set_decrypt_key(AES_KEY *aes_key, const uint8_t key[16]) {
return aes_set_decrypt_key(aes_key, key, 16);
}
static const BLOCK_CIPHER aes128_block_cipher_object = {
AES128_KEY_SIZE,
AES_BLOCK_SIZE,
(block_cipher_set_encrypt_key_func)aes128_set_encrypt_key,
(block_cipher_set_decrypt_key_func)aes128_set_decrypt_key,
(block_cipher_encrypt_func)aes_encrypt,
(block_cipher_decrypt_func)aes_encrypt,
};
const BLOCK_CIPHER *BLOCK_CIPHER_aes128(void) {
return &aes128_block_cipher_object;
}