/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 1999-2009. All Rights Reserved.
*
* The contents of this file are subject to the Erlang Public License,
* Version 1.1, (the "License"); you may not use this file except in
* compliance with the License. You should have received a copy of the
* Erlang Public License along with this software. If not, it can be
* retrieved online at http://www.erlang.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* %CopyrightEnd%
*/
/*
* Purpose: Dynamically loadable driver for cryptography libraries.
* Based on OpenSSL.
*/
#ifdef __WIN32__
#include <windows.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "erl_driver.h"
#define OPENSSL_THREAD_DEFINES
#include <openssl/opensslconf.h>
#ifndef OPENSSL_THREADS
# ifdef __GNUC__
# warning No thread support by openssl. Driver will use coarse grain locking.
# endif
#endif
#include <openssl/crypto.h>
#include <openssl/des.h>
/* #include <openssl/idea.h> This is not supported on the openssl OTP requires */
#include <openssl/dsa.h>
#include <openssl/rsa.h>
#include <openssl/aes.h>
#include <openssl/md5.h>
#include <openssl/md4.h>
#include <openssl/sha.h>
#include <openssl/bn.h>
#include <openssl/objects.h>
#include <openssl/rc4.h>
#include <openssl/rc2.h>
#include <openssl/blowfish.h>
#include <openssl/rand.h>
#ifdef VALGRIND
# include <valgrind/memcheck.h>
/* libcrypto mixes supplied buffer contents into its entropy pool,
which makes valgrind complain about the use of uninitialized data.
We use this valgrind "request" to make sure that no such seemingly
undefined data escapes the driver.
*/
# define ERL_VALGRIND_MAKE_MEM_DEFINED(ptr,size) \
VALGRIND_MAKE_MEM_DEFINED(ptr,size)
# define ERL_VALGRIND_ASSERT_MEM_DEFINED(ptr,size) \
((void) ((VALGRIND_CHECK_MEM_IS_DEFINED(ptr,size) == 0) ? 1 : \
(fprintf(stderr,"\r\n####### VALGRIND_ASSSERT(%p,%d) failed at %s:%d\r\n",\
(ptr),(size), __FILE__, __LINE__), abort(), 0)))
#else
# define ERL_VALGRIND_MAKE_MEM_DEFINED(ptr,size)
# define ERL_VALGRIND_ASSERT_MEM_DEFINED(ptr,size)
#endif
#ifdef DEBUG
# define ASSERT(e) \
((void) ((e) ? 1 : (fprintf(stderr,"Assert '%s' failed at %s:%d\n",\
#e, __FILE__, __LINE__), abort(), 0)))
#else
# define ASSERT(e) ((void) 1)
#endif
#ifdef __GNUC__
# define INLINE __inline__
#elif defined(__WIN32__)
# define INLINE __forceinline
#else
# define INLINE
#endif
#define get_int32(s) ((((unsigned char*) (s))[0] << 24) | \
(((unsigned char*) (s))[1] << 16) | \
(((unsigned char*) (s))[2] << 8) | \
(((unsigned char*) (s))[3]))
#define put_int32(s,i) \
{ (s)[0] = (char)(((i) >> 24) & 0xff);\
(s)[1] = (char)(((i) >> 16) & 0xff);\
(s)[2] = (char)(((i) >> 8) & 0xff);\
(s)[3] = (char)((i) & 0xff);\
}
/* Driver interface declarations */
static int init(void);
static void finish(void);
static ErlDrvData start(ErlDrvPort port, char *command);
static void stop(ErlDrvData drv_data);
static int crypto_control(ErlDrvData drv_data, unsigned int command, char *buf,
int len, char **rbuf, int rlen);
/* openssl callbacks */
#ifdef OPENSSL_THREADS
static void locking_function(int mode, int n, const char *file, int line);
static unsigned long id_function(void);
static struct CRYPTO_dynlock_value* dyn_create_function(const char *file,
int line);
static void dyn_lock_function(int mode, struct CRYPTO_dynlock_value* ptr,
const char *file, int line);
static void dyn_destroy_function(struct CRYPTO_dynlock_value *ptr,
const char *file, int line);
#endif /* OPENSSL_THREADS */
/* helpers */
static void hmac_md5(char *key, int klen, char *dbuf, int dlen,
char *hmacbuf);
static void hmac_sha1(char *key, int klen, char *dbuf, int dlen,
char *hmacbuf);
static ErlDrvEntry crypto_driver_entry = {
init,
start,
stop,
NULL, /* output */
NULL, /* ready_input */
NULL, /* ready_output */
"crypto_drv",
finish,
NULL, /* handle */
crypto_control,
NULL, /* timeout */
NULL, /* outputv */
NULL, /* ready_async */
NULL, /* flush */
NULL, /* call */
NULL, /* event */
ERL_DRV_EXTENDED_MARKER,
ERL_DRV_EXTENDED_MAJOR_VERSION,
ERL_DRV_EXTENDED_MINOR_VERSION,
#ifdef OPENSSL_THREADS
ERL_DRV_FLAG_USE_PORT_LOCKING,
#else
0,
#endif
NULL, /* handle2 */
NULL /* process_exit */
};
/* Keep the following definitions in alignment with the FUNC_LIST
* in crypto.erl.
*/
#define DRV_INFO 0
#define DRV_MD5 1
#define DRV_MD5_INIT 2
#define DRV_MD5_UPDATE 3
#define DRV_MD5_FINAL 4
#define DRV_SHA 5
#define DRV_SHA_INIT 6
#define DRV_SHA_UPDATE 7
#define DRV_SHA_FINAL 8
#define DRV_MD5_MAC 9
#define DRV_MD5_MAC_96 10
#define DRV_SHA_MAC 11
#define DRV_SHA_MAC_96 12
#define DRV_CBC_DES_ENCRYPT 13
#define DRV_CBC_DES_DECRYPT 14
#define DRV_EDE3_CBC_DES_ENCRYPT 15
#define DRV_EDE3_CBC_DES_DECRYPT 16
#define DRV_AES_CFB_128_ENCRYPT 17
#define DRV_AES_CFB_128_DECRYPT 18
#define DRV_RAND_BYTES 19
#define DRV_RAND_UNIFORM 20
#define DRV_MOD_EXP 21
#define DRV_DSS_VERIFY 22
#define DRV_RSA_VERIFY_SHA 23
/* #define DRV_RSA_VERIFY_MD5 35 */
#define DRV_CBC_AES128_ENCRYPT 24
#define DRV_CBC_AES128_DECRYPT 25
#define DRV_XOR 26
#define DRV_RC4_ENCRYPT 27 /* no decrypt needed; symmetric */
#define DRV_RC4_SETKEY 28
#define DRV_RC4_ENCRYPT_WITH_STATE 29
#define DRV_CBC_RC2_40_ENCRYPT 30
#define DRV_CBC_RC2_40_DECRYPT 31
#define DRV_CBC_AES256_ENCRYPT 32
#define DRV_CBC_AES256_DECRYPT 33
#define DRV_INFO_LIB 34
/* #define DRV_RSA_VERIFY_SHA 23 */
#define DRV_RSA_VERIFY_MD5 35
#define DRV_RSA_SIGN_SHA 36
#define DRV_RSA_SIGN_MD5 37
#define DRV_DSS_SIGN 38
#define DRV_RSA_PUBLIC_ENCRYPT 39
#define DRV_RSA_PRIVATE_DECRYPT 40
#define DRV_RSA_PRIVATE_ENCRYPT 41
#define DRV_RSA_PUBLIC_DECRYPT 42
#define DRV_DH_GENERATE_PARAMS 43
#define DRV_DH_CHECK 44
#define DRV_DH_GENERATE_KEY 45
#define DRV_DH_COMPUTE_KEY 46
#define DRV_MD4 47
#define DRV_MD4_INIT 48
#define DRV_MD4_UPDATE 49
#define DRV_MD4_FINAL 50
#define SSL_VERSION_0_9_8 0
#if SSL_VERSION_0_9_8
#define DRV_SHA256 51
#define DRV_SHA256_INIT 52
#define DRV_SHA256_UPDATE 53
#define DRV_SHA256_FINAL 54
#define DRV_SHA512 55
#define DRV_SHA512_INIT 56
#define DRV_SHA512_UPDATE 57
#define DRV_SHA512_FINAL 58
#endif
#define DRV_BF_CFB64_ENCRYPT 59
#define DRV_BF_CFB64_DECRYPT 60
/* #define DRV_CBC_IDEA_ENCRYPT 34 */
/* #define DRV_CBC_IDEA_DECRYPT 35 */
/* Not DRV_DH_GENERATE_PARAMS DRV_DH_CHECK
* Calc RSA_VERIFY_* and RSA_SIGN once */
#define NUM_CRYPTO_FUNCS 46
#define MD5_CTX_LEN (sizeof(MD5_CTX))
#define MD5_LEN 16
#define MD5_LEN_96 12
#define MD4_CTX_LEN (sizeof(MD4_CTX))
#define MD4_LEN 16
#define SHA_CTX_LEN (sizeof(SHA_CTX))
#define SHA_LEN 20
#define SHA_LEN_96 12
#define HMAC_INT_LEN 64
#define HMAC_IPAD 0x36
#define HMAC_OPAD 0x5c
#if SSL_VERSION_0_9_8
#define SHA256_CTX_LEN (sizeof(SHA256_CTX))
#define SHA256_LEN 32
#define SHA512_CTX_LEN (sizeof(SHA512_CTX))
#define SHA512_LEN 64
#endif
/* INITIALIZATION AFTER LOADING */
/*
* This is the init function called after this driver has been loaded.
* It must *not* be declared static. Must return the address to
* the driver entry.
*/
#if !defined(__WIN32__)
DRIVER_INIT(crypto_drv);
#endif
DRIVER_INIT(crypto_drv)
{
return &crypto_driver_entry;
}
static ErlDrvRWLock** lock_vec = NULL; /* Static locks used by openssl */
/* DRIVER INTERFACE */
static int init(void)
{
ErlDrvSysInfo sys_info;
int i;
CRYPTO_set_mem_functions(driver_alloc, driver_realloc, driver_free);
#ifdef OPENSSL_THREADS
driver_system_info(&sys_info, sizeof(sys_info));
if(sys_info.scheduler_threads > 1) {
lock_vec = driver_alloc(CRYPTO_num_locks()*sizeof(*lock_vec));
if (lock_vec==NULL) return -1;
memset(lock_vec,0,CRYPTO_num_locks()*sizeof(*lock_vec));
for(i=CRYPTO_num_locks()-1; i>=0; --i) {
lock_vec[i] = erl_drv_rwlock_create("crypto_drv_stat");
if (lock_vec[i]==NULL) return -1;
}
CRYPTO_set_locking_callback(locking_function);
CRYPTO_set_id_callback(id_function);
CRYPTO_set_dynlock_create_callback(dyn_create_function);
CRYPTO_set_dynlock_lock_callback(dyn_lock_function);
CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);
}
/* else no need for locks */
#endif /* OPENSSL_THREADS */
return 0;
}
static void finish(void)
{
/* Moved here from crypto_control() as it's not thread safe */
CRYPTO_cleanup_all_ex_data();
if(lock_vec != NULL) {
int i;
for(i=CRYPTO_num_locks()-1; i>=0; --i) {
if (lock_vec[i] != NULL) {
erl_drv_rwlock_destroy(lock_vec[i]);
}
}
driver_free(lock_vec);
}
}
static ErlDrvData start(ErlDrvPort port, char *command)
{
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
return 0; /* not used */
}
static void stop(ErlDrvData drv_data)
{
return;
}
/* Helper functions for 'crypto_control'
*/
static INLINE unsigned char* return_binary(char **rbuf, int rlen, int len)
{
if (len <= rlen) {
return (unsigned char *) *rbuf;
}
else {
ErlDrvBinary* bin;
*rbuf = (char*) (bin = driver_alloc_binary(len));
return (bin==NULL) ? NULL : (unsigned char *) bin->orig_bytes;
}
}
static INLINE unsigned char* return_binary_shrink(char **rbuf, int rlen, unsigned char* data, int len)
{
if ((char *) data == *rbuf) { /* default buffer */
ASSERT(len <= rlen);
return (unsigned char *) data;
}
else {
ErlDrvBinary* bin = (ErlDrvBinary*) *rbuf;
*rbuf = (char*) (bin=driver_realloc_binary(bin, len));
return (bin==NULL) ? NULL : (unsigned char *) bin->orig_bytes;
}
}
/* Nowadays (R13) it does matter what value control returns
* as it may return data in default buffer.
*/
static int crypto_control(ErlDrvData drv_data, unsigned int command, char *buf,
int len, char **rbuf, int rlen)
{
int klen, dlen, macsize, from_len, to_len, i;
int base_len, exponent_len, modulo_len;
int data_len, dsa_p_len, dsa_q_len;
int dsa_s_len, dsa_g_len, dsa_y_len;
int rsa_e_len, rsa_n_len, rsa_d_len, padding;
int or_mask;
int prime_len, generator;
int privkey_len, pubkey_len, dh_p_len, dh_g_len;
unsigned int rsa_s_len, j;
char *key, *key2, *dbuf;
unsigned char *p;
const_DES_cblock *des_key, *des_key2, *des_key3;
const unsigned char *des_dbuf;
BIGNUM *bn_from, *bn_to, *bn_rand, *bn_result;
BIGNUM *bn_base, *bn_exponent, *bn_modulo;
BIGNUM *dsa_p, *dsa_q, *dsa_g, *dsa_y;
BIGNUM *rsa_n, *rsa_e, *rsa_d;
BIGNUM *dh_p, *dh_g, *privkey, *pubkey;
DES_cblock *des_ivec;
unsigned char* bin;
DES_key_schedule schedule, schedule2, schedule3;
DH *dh_params;
/* IDEA_KEY_SCHEDULE idea, idea2; */
char hmacbuf[SHA_DIGEST_LENGTH];
unsigned char *rsa_s, *dsa_s;
/* char hmacbuf[SHA_LEN]; */
#if SSL_VERSION_0_9_8
SHA256_CTX sha256_ctx;
SHA512_CTX sha512_ctx;
#endif
MD5_CTX md5_ctx;
MD4_CTX md4_ctx;
SHA_CTX sha_ctx;
int new_ivlen = 0;
BN_CTX *bn_ctx;
DSA *dsa;
RSA *rsa;
AES_KEY aes_key;
RC4_KEY rc4_key;
RC2_KEY rc2_key;
switch(command) {
case DRV_INFO:
bin = return_binary(rbuf,rlen,NUM_CRYPTO_FUNCS);
if (bin==NULL) return -1;
for (i = 0; i < NUM_CRYPTO_FUNCS; i++) {
bin[i] = i + 1;
}
return NUM_CRYPTO_FUNCS;
case DRV_MD5:
bin = return_binary(rbuf,rlen,MD5_LEN);
if (bin==NULL) return -1;
MD5((unsigned char *) buf, len, bin);
return MD5_LEN;
case DRV_MD5_INIT:
bin = return_binary(rbuf,rlen,MD5_CTX_LEN);
if (bin==NULL) return -1;
MD5_Init((MD5_CTX *)bin);
return MD5_CTX_LEN;
case DRV_MD5_UPDATE:
if (len < MD5_CTX_LEN)
return -1;
bin = return_binary(rbuf,rlen,MD5_CTX_LEN);
if (bin==NULL) return -1;
memcpy(bin, buf, MD5_CTX_LEN);
MD5_Update((MD5_CTX *)bin, buf + MD5_CTX_LEN,
len - MD5_CTX_LEN);
return MD5_CTX_LEN;
case DRV_MD5_FINAL:
if (len != MD5_CTX_LEN)
return -1;
memcpy(&md5_ctx, buf, MD5_CTX_LEN); /* XXX Use buf only? */
bin = return_binary(rbuf,rlen,MD5_LEN);
if (bin==NULL) return -1;
MD5_Final(bin, &md5_ctx);
return MD5_LEN;
case DRV_SHA:
bin = return_binary(rbuf,rlen,SHA_LEN);
if (bin==NULL) return -1;
SHA1((unsigned char *) buf, len, bin);
return SHA_LEN;
case DRV_SHA_INIT:
bin = return_binary(rbuf,rlen,SHA_CTX_LEN);
if (bin==NULL) return -1;
SHA1_Init((SHA_CTX*)bin);
return SHA_CTX_LEN;
case DRV_SHA_UPDATE:
if (len < SHA_CTX_LEN)
return -1;
bin = return_binary(rbuf,rlen,SHA_CTX_LEN);
if (bin==NULL) return -1;
memcpy(bin, buf, SHA_CTX_LEN);
SHA1_Update((SHA_CTX*)bin, buf + SHA_CTX_LEN, len - SHA_CTX_LEN);
return SHA_CTX_LEN;
case DRV_SHA_FINAL:
if (len != SHA_CTX_LEN)
return -1;
memcpy(&sha_ctx, buf, SHA_CTX_LEN); /* XXX Use buf only? */
bin = return_binary(rbuf,rlen,SHA_LEN);
if (bin==NULL) return -1;
SHA1_Final(bin, &sha_ctx);
return SHA_LEN;
case DRV_MD5_MAC:
case DRV_MD5_MAC_96:
/* buf = klen[4] key data */
klen = get_int32(buf);
key = buf + 4;
dlen = len - klen - 4;
dbuf = key + klen;
hmac_md5(key, klen, dbuf, dlen, hmacbuf);
macsize = (command == DRV_MD5_MAC) ? MD5_LEN : MD5_LEN_96;
bin = return_binary(rbuf,rlen,macsize);
if (bin==NULL) return -1;
memcpy(bin, hmacbuf, macsize);
return macsize;
case DRV_SHA_MAC:
case DRV_SHA_MAC_96:
/* buf = klen[4] key data */
klen = get_int32(buf);
key = buf + 4;
dlen = len - klen - 4;
dbuf = key + klen;
hmac_sha1(key, klen, dbuf, dlen, hmacbuf);
macsize = (command == DRV_SHA_MAC) ? SHA_LEN : SHA_LEN_96;
bin = return_binary(rbuf,rlen,macsize);
if (bin==NULL) return -1;
memcpy(bin, (unsigned char *) hmacbuf, macsize);
return macsize;
case DRV_CBC_DES_ENCRYPT:
case DRV_CBC_DES_DECRYPT:
/* buf = key[8] ivec[8] data */
dlen = len - 16;
if (dlen < 0)
return -1;
if (dlen % 8 != 0)
return -1;
des_key = (const_DES_cblock*) buf;
des_ivec = (DES_cblock*)(buf + 8);
des_dbuf = (unsigned char *) (buf + 16);
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
DES_set_key(des_key, &schedule);
DES_ncbc_encrypt(des_dbuf, bin, dlen, &schedule, des_ivec,
(command == DRV_CBC_DES_ENCRYPT));
return dlen;
case DRV_BF_CFB64_ENCRYPT:
case DRV_BF_CFB64_DECRYPT:
{
/* buf = klen[4] key ivec[8] data */
unsigned char* ivec;
unsigned char bf_tkey[8]; /* blowfish ivec */
int bf_n; /* blowfish ivec pos */
int bf_direction;
const unsigned char *bf_dbuf; /* blowfish input data */
BF_KEY bf_key; /* blowfish key 8 */
klen = get_int32(buf);
key = buf + 4;
ivec = (unsigned char *) (key + klen);
bf_dbuf = ivec + 8;
dlen = len - 4 - klen - 8;
if (dlen < 0) return -1;
BF_set_key(&bf_key, klen, (unsigned char *) key);
memcpy(bf_tkey, ivec, 8);
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
bf_direction = command == DRV_BF_CFB64_ENCRYPT ? BF_ENCRYPT : BF_DECRYPT;
bf_n = 0;
BF_cfb64_encrypt(bf_dbuf, bin, dlen, &bf_key, bf_tkey, &bf_n, bf_direction);
return dlen;
}
/* case DRV_CBC_IDEA_ENCRYPT: */
/* case DRV_CBC_IDEA_DECRYPT: */
/* buf = key[16] ivec[8] data */
/* dlen = len - 24; */
/* if (dlen < 0) */
/* return -1; */
/* if (dlen % 8 != 0) */
/* return -1; */
/* bin = return_binary(rbuf,rlen,dlen); */
/* idea_set_encrypt_key(buf, &idea); */
/* if (command == DRV_CBC_IDEA_DECRYPT) { */
/* idea_set_decrypt_key(&idea, &idea2); */
/* memcpy(&idea, &idea2, sizeof(idea)); */
/* } */
/* idea_cbc_encrypt(buf + 24, bin, dlen, &idea, buf + 8, */
/* (command == DRV_CBC_IDEA_ENCRYPT)); */
/* return dlen; */
case DRV_CBC_RC2_40_ENCRYPT:
case DRV_CBC_RC2_40_DECRYPT:
/* buf = key[5] ivec[8] data */
dlen = len - 13;
if (dlen < 0)
return -1;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
RC2_set_key(&rc2_key, 5, (unsigned char *) buf, 40);
RC2_cbc_encrypt((unsigned char *) (buf + 13), bin, dlen, &rc2_key,
(unsigned char *) (buf + 5),
(command == DRV_CBC_RC2_40_ENCRYPT));
return dlen;
case DRV_EDE3_CBC_DES_ENCRYPT:
case DRV_EDE3_CBC_DES_DECRYPT:
dlen = len - 32;
if (dlen < 0)
return -1;
des_key = (const_DES_cblock*) buf;
des_key2 = (const_DES_cblock*) (buf + 8);
des_key3 = (const_DES_cblock*) (buf + 16);
des_ivec = (DES_cblock*) (buf + 24);
des_dbuf = (unsigned char *) (buf + 32);
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
DES_set_key(des_key, &schedule);
DES_set_key(des_key2, &schedule2);
DES_set_key(des_key3, &schedule3);
DES_ede3_cbc_encrypt(des_dbuf, bin, dlen, &schedule,
&schedule2, &schedule3, des_ivec,
(command == DRV_EDE3_CBC_DES_ENCRYPT));
return dlen;
case DRV_AES_CFB_128_ENCRYPT:
case DRV_AES_CFB_128_DECRYPT:
/* buf = key[16] ivec[16] data */
dlen = len - 32;
if (dlen < 0)
return -1;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
AES_set_encrypt_key((unsigned char *) buf, 128, &aes_key);
AES_cfb128_encrypt((unsigned char *) (buf+32), bin, dlen, &aes_key,
(unsigned char *) (buf+16), &new_ivlen,
(command == DRV_AES_CFB_128_ENCRYPT));
return dlen;
case DRV_RC4_ENCRYPT:
/* buf = klen[4] key data */
klen = get_int32(buf);
key = buf + 4;
dlen = len - klen - 4;
dbuf = key + klen;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
RC4_set_key(&rc4_key, klen, (unsigned char *) key);
RC4(&rc4_key, dlen, (unsigned char *) dbuf, bin);
return dlen;
case DRV_RC4_SETKEY:
/* buf = key */
dlen = sizeof(rc4_key);
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
RC4_set_key(&rc4_key, len, (unsigned char *) buf);
memcpy(bin, &rc4_key, dlen);
return dlen;
case DRV_RC4_ENCRYPT_WITH_STATE:
/* buf = statelength[4] state data, return statelength[4] state data */
klen = get_int32(buf);
key = buf + 4;
dlen = len - klen - 4;
dbuf = key + klen;
bin = return_binary(rbuf,rlen,len);
if (bin==NULL) return -1;
memcpy(&rc4_key, key, klen);
RC4(&rc4_key, dlen, (unsigned char *) dbuf, bin + klen + 4);
memcpy(bin, buf, 4);
memcpy(bin + 4, &rc4_key, klen);
return len;
case DRV_RAND_BYTES:
/* buf = <<rlen:32/integer,topmask:8/integer,bottommask:8/integer>> */
if (len != 6)
return -1;
dlen = get_int32(buf);
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
RAND_pseudo_bytes(bin,dlen);
ERL_VALGRIND_MAKE_MEM_DEFINED(bin, dlen);
or_mask = ((unsigned char*)buf)[4];
bin[dlen-1] |= or_mask; /* topmask */
or_mask = ((unsigned char*)buf)[5];
bin[0] |= or_mask; /* bottommask */
return dlen;
case DRV_RAND_UNIFORM:
/* buf = <<from_len:32/integer,bn_from:from_len/binary, *
* to_len:32/integer,bn_to:to_len/binary>> */
if (len < 8)
return -1;
from_len = get_int32(buf);
if (len < (8 + from_len))
return -1;
to_len = get_int32(buf + 4 + from_len);
if (len != (8 + from_len + to_len))
return -1;
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf, 4 + from_len + 4 + to_len);
bn_from = BN_new();
BN_bin2bn((unsigned char *)(buf + 4), from_len, bn_from);
bn_rand = BN_new();
BN_bin2bn((unsigned char *)(buf + 8 + from_len), to_len, bn_rand);
bn_to = BN_new();
BN_sub(bn_to, bn_rand, bn_from);
BN_pseudo_rand_range(bn_rand, bn_to);
BN_add(bn_rand, bn_rand, bn_from);
dlen = BN_num_bytes(bn_rand);
bin = return_binary(rbuf,rlen,dlen + 4);
if (bin==NULL) return -1;
put_int32(bin, dlen);
BN_bn2bin(bn_rand,(unsigned char*)(bin + 4));
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+4, dlen);
BN_free(bn_rand);
BN_free(bn_from);
BN_free(bn_to);
return dlen + 4;
case DRV_MOD_EXP:
/* buf = <<base_len:32/integer,base/binary, *
* exponent_len:32/integer,exponent/binary, *
* modulo_len:32/integer, modulo/binary>> */
if (len < 12)
return -1;
base_len = get_int32(buf);
if (len < (12 + base_len))
return -1;
exponent_len = get_int32(buf + 4 + base_len);
if (len < (12 + base_len + exponent_len))
return -1;
modulo_len = get_int32(buf + 8 + base_len + exponent_len);
if (len != (12 + base_len + exponent_len + modulo_len))
return -1;
bn_base = BN_new();
BN_bin2bn((unsigned char *)(buf + 4),
base_len, bn_base);
bn_exponent = BN_new();
BN_bin2bn((unsigned char *)(buf + 8 + base_len),
exponent_len, bn_exponent);
bn_modulo = BN_new();
BN_bin2bn((unsigned char *)(buf + 12 + base_len + exponent_len),
modulo_len, bn_modulo);
bn_result = BN_new();
bn_ctx = BN_CTX_new();
BN_mod_exp(bn_result, bn_base, bn_exponent,
bn_modulo, bn_ctx);
dlen = BN_num_bytes(bn_result);
bin = return_binary(rbuf,rlen,dlen + 4);
if (bin==NULL) return -1;
put_int32(bin, dlen);
BN_bn2bin(bn_result,(unsigned char*)(bin + 4));
BN_free(bn_result);
BN_free(bn_modulo);
BN_free(bn_exponent);
BN_free(bn_base);
BN_CTX_free(bn_ctx);
return dlen + 4;
case DRV_DSS_VERIFY:
/* buf = <<data_len:32/integer, data:data_len/binary,
* dsa_s_len:32/integer, dsa_s:dsa_s_len/binary,
* dsa_p_len:32/integer, dsa_p:dsa_p_len/binary,
* dsa_q_len:32/integer, dsa_q:dsa_q_len/binary,
* dsa_g_len:32/integer, dsa_g:dsa_g_len/binary,
* dsa_y_len:32/integer, dsa_y:dsa_y_len/binary>> */
i = 0;
j = 0;
if (len < 24)
return -1;
data_len = get_int32(buf + i + j);
j += data_len; i += 4;
if (len < (24 + j))
return -1;
dsa_s_len = get_int32(buf + i + j);
j += dsa_s_len; i += 4;
if (len < (24 + j))
return -1;
dsa_p_len = get_int32(buf + i + j);
j += dsa_p_len; i += 4;
if (len < (24 + j))
return -1;
dsa_q_len = get_int32(buf + i + j);
j += dsa_q_len; i += 4;
if (len < (24 + j))
return -1;
dsa_g_len = get_int32(buf + i + j);
j += dsa_g_len; i += 4;
if (len < (24 + j))
return -1;
dsa_y_len = get_int32(buf + i + j);
j += dsa_y_len;
if (len != (24 + j))
return -1;
i = 4;
SHA1((unsigned char *) (buf + i), data_len, (unsigned char *) hmacbuf);
i += data_len + 4;
dsa_s = (unsigned char *)(buf + i);
i += (dsa_s_len + 4);
dsa_p = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_p_len, dsa_p);
i += (dsa_p_len + 4);
dsa_q = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_q_len, dsa_q);
i += (dsa_q_len + 4);
dsa_g = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_g_len, dsa_g);
i += (dsa_g_len + 4);
dsa_y = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_y_len, dsa_y);
dsa = DSA_new();
dsa->p = dsa_p;
dsa->q = dsa_q;
dsa->g = dsa_g;
dsa->priv_key = NULL;
dsa->pub_key = dsa_y;
i = DSA_verify(0, (unsigned char *) hmacbuf, SHA_DIGEST_LENGTH,
dsa_s, dsa_s_len, dsa);
bin = return_binary(rbuf,rlen,1);
if (bin==NULL) return -1;
DSA_free(dsa);
bin[0] = (i > 0) ? 1 : 0;
return 1;
case DRV_DSS_SIGN:
/* buf = <<data_len:32/integer, data:data_len/binary,
* dsa_p_len:32/integer, dsa_p:dsa_p_len/binary,
* dsa_q_len:32/integer, dsa_q:dsa_q_len/binary,
* dsa_g_len:32/integer, dsa_g:dsa_g_len/binary,
* dsa_y_len:32/integer, dsa_y:dsa_y_len/binary,
* dsa_x_len:32/integer, dsa_s:dsa_x_len/binary>> */
i = 0;
j = 0;
if (len < 20)
return -1;
data_len = get_int32(buf + i + j);
j += data_len; i += 4;
if (len < (20 + j))
return -1;
dsa_p_len = get_int32(buf + i + j);
j += dsa_p_len; i += 4;
if (len < (20 + j))
return -1;
dsa_q_len = get_int32(buf + i + j);
j += dsa_q_len; i += 4;
if (len < (20 + j))
return -1;
dsa_g_len = get_int32(buf + i + j);
j += dsa_g_len; i += 4;
if (len < (20 + j))
return -1;
dsa_y_len = get_int32(buf + i + j);
j += dsa_y_len;
if (len < (20 + j))
return -1;
if (len != (20 + j))
return -1;
i = 4;
SHA1((unsigned char *) (buf + i), data_len, (unsigned char *) hmacbuf);
i += data_len + 4;
dsa_p = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_p_len, dsa_p);
i += (dsa_p_len + 4);
dsa_q = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_q_len, dsa_q);
i += (dsa_q_len + 4);
dsa_g = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_g_len, dsa_g);
i += (dsa_g_len + 4);
dsa_y = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dsa_y_len, dsa_y);
/* i += (dsa_y_len + 4); */
dsa = DSA_new();
dsa->p = dsa_p;
dsa->q = dsa_q;
dsa->g = dsa_g;
dsa->priv_key = dsa_y;
dsa->pub_key = NULL;
dlen = DSA_size(dsa);
bin = return_binary(rbuf,rlen, dlen+1);
if (bin==NULL) return -1;
i = DSA_sign(NID_sha1,
(unsigned char *) hmacbuf,SHA_DIGEST_LENGTH,
(unsigned char *) &bin[1],
(unsigned int *) &dsa_s_len, dsa);
DSA_free(dsa);
if (i) {
if (dsa_s_len != dlen) {
bin = return_binary_shrink(rbuf,rlen,bin,dsa_s_len+1);
}
bin[0] = 1;
return dsa_s_len + 1;
}
else {
bin[0] = 0;
return 1;
}
case DRV_RSA_VERIFY_MD5:
case DRV_RSA_VERIFY_SHA:
/* buf = <<data_len:32/integer, data:data_len/binary,
* rsa_s_len:32/integer, rsa_s:rsa_s_len/binary,
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
* rsa_n_len:32/integer, rsa_n:rsa_n_len/binary>> */
i = 0;
j = 0;
if (len < 16)
return -1;
data_len = get_int32(buf + i + j);
j += data_len; i += 4;
if (len < (16 + j))
return -1;
rsa_s_len = get_int32(buf + i + j);
j += rsa_s_len; i += 4;
if (len < (16 + j))
return -1;
rsa_e_len = get_int32(buf + i + j);
j += rsa_e_len; i += 4;
if (len < (16 + j))
return -1;
rsa_n_len = get_int32(buf + i + j);
j += rsa_n_len; i += 4;
if (len != (16 + j))
return -1;
i = 4;
i += (data_len + 4);
rsa_s = (unsigned char *)(buf + i);
i += (rsa_s_len + 4);
rsa_e = BN_new();
BN_bin2bn((unsigned char *)(buf + i), rsa_e_len, rsa_e);
i += (rsa_e_len + 4);
rsa_n = BN_new();
BN_bin2bn((unsigned char *)(buf + i), rsa_n_len, rsa_n);
rsa = RSA_new();
rsa->n = rsa_n;
rsa->e = rsa_e;
i = 4;
if(command == DRV_RSA_VERIFY_SHA) {
SHA1((unsigned char *) (buf + i), data_len,
(unsigned char *) hmacbuf);
i = RSA_verify(NID_sha1, (unsigned char *) hmacbuf, SHA_DIGEST_LENGTH,
rsa_s, rsa_s_len, rsa);
} else {
MD5((unsigned char *) (buf + i), data_len, (unsigned char *) hmacbuf);
i = RSA_verify(NID_md5, (unsigned char *) hmacbuf, MD5_DIGEST_LENGTH,
rsa_s, rsa_s_len, rsa);
}
bin = return_binary(rbuf,rlen,1);
if (bin==NULL) return -1;
bin[0] = (char)(i & 0xff);
RSA_free(rsa);
return 1;
case DRV_RSA_SIGN_MD5:
case DRV_RSA_SIGN_SHA:
/* buf = <<data_len:32/integer, data:data_len/binary,
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
* rsa_n_len:32/integer, rsa_n:rsa_n_len/binary,
* rsa_d_len:32/integer, rsa_d:rsa_d_len/binary>> */
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf,len);
i = 0;
j = 0;
if (len < 16)
return -1;
data_len = get_int32(buf + i + j);
j += data_len; i += 4;
if (len < (16 + j))
return -1;
rsa_e_len = get_int32(buf + i + j);
j += rsa_e_len; i += 4;
if (len < (16 + j))
return -1;
rsa_n_len = get_int32(buf + i + j);
j += rsa_n_len; i += 4;
if (len < (16 + j))
return -1;
rsa_d_len = get_int32(buf + i + j);
j += rsa_d_len; i += 4;
if (len != (16 + j))
return -1;
i = 4;
i += (data_len + 4);
rsa_e = BN_new();
BN_bin2bn((unsigned char *)(buf + i), rsa_e_len, rsa_e);
i += (rsa_e_len + 4);
rsa_n = BN_new();
BN_bin2bn((unsigned char *)(buf + i), rsa_n_len, rsa_n);
i += (rsa_n_len + 4);
rsa_d = BN_new();
BN_bin2bn((unsigned char *)(buf + i), rsa_d_len, rsa_d);
i += (rsa_d_len + 4);
rsa = RSA_new();
rsa->e = rsa_e;
rsa->n = rsa_n;
rsa->d = rsa_d;
dlen = RSA_size(rsa);
bin = return_binary(rbuf,rlen,dlen+1);
if (bin==NULL) return -1;
i = 4;
if (command == DRV_RSA_SIGN_MD5) {
MD5((unsigned char *) (buf + i), data_len, (unsigned char *) hmacbuf);
ERL_VALGRIND_ASSERT_MEM_DEFINED(hmacbuf, MD5_DIGEST_LENGTH);
i = RSA_sign(NID_md5,
(unsigned char *) hmacbuf,MD5_DIGEST_LENGTH,
(unsigned char *) &bin[1],
&rsa_s_len, rsa);
} else {
SHA1((unsigned char *) (buf + i), data_len,
(unsigned char *) hmacbuf);
ERL_VALGRIND_ASSERT_MEM_DEFINED(hmacbuf, SHA_DIGEST_LENGTH);
i = RSA_sign(NID_sha1,
(unsigned char *) hmacbuf,SHA_DIGEST_LENGTH,
(unsigned char *) &bin[1],
&rsa_s_len, rsa);
}
RSA_free(rsa);
if (i) {
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+1, rsa_s_len);
if (rsa_s_len != dlen) {
bin = return_binary_shrink(rbuf,rlen,bin,rsa_s_len+1);
ERL_VALGRIND_ASSERT_MEM_DEFINED(bin+1, rsa_s_len);
}
bin[0] = 1;
return rsa_s_len + 1;
}
else {
bin[0] = 0;
return 1;
}
case DRV_RSA_PRIVATE_DECRYPT:
case DRV_RSA_PRIVATE_ENCRYPT:
/* buf = <<data_len:32/integer, data:data_len/binary,
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
* rsa_n_len:32/integer, rsa_n:rsa_n_len/binary,
* rsa_d_len:32/integer, rsa_d:rsa_d_len/binary,
* pad:8/integer >> */
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf,len);
i = 0;
j = 0;
if (len < 17)
return -1;
data_len = get_int32(buf + i + j);
j += data_len; i += 4;
if (len < (17 + j))
return -1;
rsa_e_len = get_int32(buf + i + j);
j += rsa_e_len; i += 4;
if (len < (17 + j))
return -1;
rsa_n_len = get_int32(buf + i + j);
j += rsa_n_len; i += 4;
if (len < (17 + j))
return -1;
rsa_d_len = get_int32(buf + i + j);
j += rsa_d_len; i += 4;
padding = *(unsigned char *) (buf+i+j);
if (len != (17 + j))
return -1;
i = 4;
i += (data_len + 4);
rsa_e = BN_new();
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf+i,rsa_e_len);
BN_bin2bn((unsigned char *)(buf + i), rsa_e_len, rsa_e);
i += (rsa_e_len + 4);
rsa_n = BN_new();
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf+i,rsa_n_len);
BN_bin2bn((unsigned char *)(buf + i), rsa_n_len, rsa_n);
i += (rsa_n_len + 4);
rsa_d = BN_new();
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf+i,rsa_d_len);
BN_bin2bn((unsigned char *)(buf + i), rsa_d_len, rsa_d);
i += (rsa_d_len + 4);
switch(padding) {
case 0:
padding = RSA_NO_PADDING;
break;
case 1:
padding = RSA_PKCS1_PADDING;
break;
case 2:
padding = RSA_PKCS1_OAEP_PADDING;
break;
case 3:
padding = RSA_SSLV23_PADDING;
break;
default:
return -1;
}
rsa = RSA_new();
rsa->e = rsa_e;
rsa->n = rsa_n;
rsa->d = rsa_d;
dlen = RSA_size(rsa) + 1;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
i = 4;
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf+i,data_len);
if(command == DRV_RSA_PRIVATE_DECRYPT) {
i = RSA_private_decrypt(data_len, (unsigned char *) (buf+i),
(unsigned char *) &bin[1],
rsa, padding);
if(i > 0) {
ERL_VALGRIND_MAKE_MEM_DEFINED(&bin[1],i);
bin = return_binary_shrink(rbuf,rlen, bin, i+1);
if (bin==NULL) return -1;
}
} else {
i = RSA_private_encrypt(data_len, (unsigned char *) (buf+i),
(unsigned char *) &bin[1],
rsa, padding);
if(i > 0) {
ERL_VALGRIND_MAKE_MEM_DEFINED(&bin[1],i);
}
}
RSA_free(rsa);
if(i > 0) {
bin[0] = 1;
return i + 1;
} else {
bin[0] = 0;
return 1;
}
break;
case DRV_RSA_PUBLIC_ENCRYPT:
case DRV_RSA_PUBLIC_DECRYPT:
/* buf = <<data_len:32/integer, data:data_len/binary,
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
* rsa_n_len:32/integer, rsa_n:rsa_n_len/binary,
* pad:8/integer >> */
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf,len);
i = 0;
j = 0;
if (len < 13)
return -1;
data_len = get_int32(buf + i + j);
j += data_len; i += 4;
if (len < (13 + j))
return -1;
rsa_e_len = get_int32(buf + i + j);
j += rsa_e_len; i += 4;
if (len < (13 + j))
return -1;
rsa_n_len = get_int32(buf + i + j);
j += rsa_n_len; i += 4;
if (len < (13 + j))
return -1;
padding = *(unsigned char *) (buf + i + j);
if (len != (13 + j))
return -1;
i = 4;
i += (data_len + 4);
rsa_e = BN_new();
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf+i,rsa_e_len);
BN_bin2bn((unsigned char *)(buf + i), rsa_e_len, rsa_e);
i += (rsa_e_len + 4);
rsa_n = BN_new();
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf+i,rsa_n_len);
BN_bin2bn((unsigned char *)(buf + i), rsa_n_len, rsa_n);
i += (rsa_n_len + 4);
switch(padding) {
case 0:
padding = RSA_NO_PADDING;
break;
case 1:
padding = RSA_PKCS1_PADDING;
break;
case 2:
padding = RSA_PKCS1_OAEP_PADDING;
break;
case 3:
padding = RSA_SSLV23_PADDING;
break;
default:
return -1;
}
rsa = RSA_new();
rsa->e = rsa_e;
rsa->n = rsa_n;
dlen = RSA_size(rsa) + 1;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
i = 4;
if(command == DRV_RSA_PUBLIC_ENCRYPT) {
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf+i,data_len);
i = RSA_public_encrypt(data_len, (unsigned char *) (buf+i),
(unsigned char *) &bin[1],
rsa, padding);
if (i > 0) {
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+1, i);
}
} else {
i = RSA_public_decrypt(data_len, (unsigned char *) (buf+i),
(unsigned char *) &bin[1],
rsa, padding);
if(i > 0) {
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+1, i);
bin = return_binary_shrink(rbuf,rlen,bin, i+1);
if (bin==NULL) return -1;
}
}
RSA_free(rsa);
if(i > 0) {
bin[0] = 1;
return i + 1;
} else {
/* ERR_load_crypto_strings(); */
/* fprintf(stderr, "%d: %s \r\n", __LINE__, ERR_reason_error_string(ERR_get_error())); */
bin[0] = 0;
return 1;
}
break;
case DRV_CBC_AES128_ENCRYPT:
case DRV_CBC_AES256_ENCRYPT:
case DRV_CBC_AES128_DECRYPT:
case DRV_CBC_AES256_DECRYPT:
/* buf = key[klen] ivec[klen] data */
if (command == DRV_CBC_AES256_ENCRYPT || command == DRV_CBC_AES256_DECRYPT)
klen = 32;
else
klen = 16;
dlen = len - klen - 16;
if (dlen < 0)
return -1;
if (dlen % 16 != 0)
return -1;
if (command == DRV_CBC_AES128_ENCRYPT || command == DRV_CBC_AES256_ENCRYPT) {
i = AES_ENCRYPT;
AES_set_encrypt_key((unsigned char *) buf, klen*8, &aes_key);
} else {
i = AES_DECRYPT;
AES_set_decrypt_key((unsigned char *) buf, klen*8, &aes_key);
}
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
AES_cbc_encrypt((unsigned char *) (buf + klen+16),
(unsigned char *) bin,
dlen,
&aes_key,
(unsigned char *) (buf + klen),
i);
return dlen;
/* case DRV_CBC_AES128_DECRYPT: */
/* case DRV_CBC_AES256_DECRYPT: */
/* /\* buf = key[klen] ivec[16] data *\/ */
/* if (command == DRV_CBC_AES256_DECRYPT) */
/* klen = 32; */
/* else */
/* klen = 16; */
/* dlen = len - klen - 16; */
/* if (dlen < 0) */
/* return -1; */
/* *rbuf = (char *)(bin = driver_alloc_binary(dlen)); */
/* AES_set_decrypt_key((unsigned char *) buf, klen*8, &aes_key); */
/* AES_cbc_encrypt((unsigned char *) (buf + klen+16), */
/* (unsigned char *) bin->orig_bytes, */
/* dlen, */
/* &aes_key, */
/* (unsigned char *) (buf + klen), */
/* AES_DECRYPT); */
/* return dlen; */
/* break; */
case DRV_XOR:
/* buf = data1, data2 with same size */
dlen = len / 2;
if (len != dlen * 2)
return -1;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
p = bin,
dbuf = buf + dlen;
for (key = buf, key2 = dbuf; key != dbuf; ++key, ++key2, ++p)
*p = *key ^ *key2;
return dlen;
case DRV_DH_GENERATE_PARAMS:
/* buf = <<PrimeLen:32 Generator:32>> */
if (len != 8)
return -1;
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf,len);
prime_len = get_int32(buf);
generator = get_int32(buf+4);
dh_params = DH_generate_parameters(prime_len, generator, NULL, NULL);
if(dh_params) {
dh_p_len = BN_num_bytes(dh_params->p);
dh_g_len = BN_num_bytes(dh_params->g);
dlen = 1 + 4 + 4 + dh_g_len + dh_p_len;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
bin[0] = 1;
put_int32(bin+1, dh_p_len);
BN_bn2bin(dh_params->p, bin+5);
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+5,dh_p_len);
put_int32(bin+5+dh_p_len, dh_g_len);
BN_bn2bin(dh_params->g, bin+5+dh_p_len+4);
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+5+dh_p_len+4,dh_g_len);
} else {
dlen = 1;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
bin[0] = 0;
}
DH_free(dh_params);
return dlen;
case DRV_DH_CHECK:
/* buf = <<dh_p_len:32/integer, dh_p:dh_p_len/binary,
* dh_g_len:32/integer, dh_g:dh_g_len/binary>> */
i = 0;
j = 0;
if(len < 8) return -1;
dh_p_len = get_int32(buf + i + j);
j += dh_p_len; i += 4;
if (len < (8 + j)) return -1;
dh_g_len = get_int32(buf + i + j);
j += dh_g_len; i += 4;
if(len != (8+j)) return -1;
i=4;
dh_p = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dh_p_len, dh_p);
i += (dh_p_len + 4);
dh_g = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dh_g_len, dh_g);
/* i += (dsa_g_len + 4); */
dh_params = DH_new();
dh_params->p = dh_p;
dh_params->g = dh_g;
i=0;
bin = return_binary(rbuf,rlen,4);
if (bin==NULL) return -1;
if(DH_check(dh_params, &i)) {
put_int32(bin, i);
} else {
/* Check Failed */
put_int32(bin, -1);
}
DH_free(dh_params);
return 4;
case DRV_DH_GENERATE_KEY:
/* buf = <<key_len:32, key:key_len/binary, *
* dh_p_len:32/integer, dh_p:dh_p_len/binary, *
* dh_g_len:32/integer, dh_g:dh_g_len/binary>> */
ERL_VALGRIND_ASSERT_MEM_DEFINED(buf,len);
i = 0;
j = 0;
if(len < 12) return -1;
base_len = get_int32(buf + i + j);
j += base_len; i += 4;
if (len < (12 + j)) return -1;
dh_p_len = get_int32(buf + i + j);
j += dh_p_len; i += 4;
if (len < (12 + j)) return -1;
dh_g_len = get_int32(buf + i + j);
j += dh_g_len; i += 4;
if(len != (12 + j)) return -1;
i=4;
i += (base_len + 4);
dh_p = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dh_p_len, dh_p);
i += (dh_p_len + 4);
dh_g = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dh_g_len, dh_g);
/* i += (dsa_g_len + 4); */
dh_params = DH_new();
dh_params->p = dh_p;
dh_params->g = dh_g;
if(base_len > 0) {
dh_params->priv_key = BN_new();
BN_bin2bn((unsigned char *)(buf + i), base_len,
dh_params->priv_key);
}
i=0;
if(DH_generate_key(dh_params)) {
privkey_len = BN_num_bytes(dh_params->priv_key);
pubkey_len = BN_num_bytes(dh_params->pub_key);
dlen = 1 + 4 + 4 + pubkey_len + privkey_len;
bin = return_binary(rbuf,rlen, dlen);
if (bin==NULL) return -1;
bin[0] = 1;
put_int32(bin+1, pubkey_len);
BN_bn2bin(dh_params->pub_key, bin+5);
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+5, pubkey_len);
put_int32(bin+5+pubkey_len, privkey_len);
BN_bn2bin(dh_params->priv_key, bin+5+pubkey_len+4);
ERL_VALGRIND_MAKE_MEM_DEFINED(bin+5+pubkey_len+4, privkey_len);
} else {
dlen = 1;
bin = return_binary(rbuf,rlen,dlen);
if (bin==NULL) return -1;
bin[0] = 0;
}
DH_free(dh_params);
return dlen;
case DRV_DH_COMPUTE_KEY:
/* buf = <<pubkey_len:32, pubkey:pubkey_len/binary, *
* privkey_len:32, privkey:privkey_len/binary, *
* dh_p_len:32/integer, dh_p:dh_p_len/binary, *
* dh_g_len:32/integer, dh_g:dh_g_len/binary>> */
i = 0;
j = 0;
if(len < 16) return -1;
pubkey_len = get_int32(buf + i + j);
j += pubkey_len; i += 4;
if (len < (16 + j)) return -1;
privkey_len = get_int32(buf + i + j);
j += privkey_len; i += 4;
if (len < (16 + j)) return -1;
dh_p_len = get_int32(buf + i + j);
j += dh_p_len; i += 4;
if (len < (16 + j)) return -1;
dh_g_len = get_int32(buf + i + j);
j += dh_g_len; i += 4;
if(len != (16 + j)) return -1;
i=4;
pubkey = BN_new();
BN_bin2bn((unsigned char *)(buf + i), pubkey_len, pubkey);
i += (pubkey_len + 4);
privkey = BN_new();
BN_bin2bn((unsigned char *)(buf + i), privkey_len, privkey);
i += (privkey_len + 4);
dh_p = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dh_p_len, dh_p);
i += (dh_p_len + 4);
dh_g = BN_new();
BN_bin2bn((unsigned char *)(buf + i), dh_g_len, dh_g);
/* i += (dsa_g_len + 4); */
dh_params = DH_new();
dh_params->p = dh_p;
dh_params->g = dh_g;
dh_params->priv_key = privkey;
klen = DH_size(dh_params);
bin = return_binary(rbuf,rlen,1+klen);
if (bin==NULL) return -1;
i = DH_compute_key(&bin[1], pubkey, dh_params);
DH_free(dh_params);
if (i > 0) {
if (i != klen) {
bin = return_binary_shrink(rbuf,rlen,bin,1+i);
}
bin[0] = 1;
return i + 1;
}
else {
bin[0] = 0;
return 1;
}
case DRV_MD4:
bin = return_binary(rbuf,rlen,MD4_LEN);
MD4((unsigned char *)buf, len, (unsigned char *)bin);
return MD4_LEN;
case DRV_MD4_INIT:
bin = return_binary(rbuf,rlen,MD4_CTX_LEN);
MD4_Init((MD4_CTX *) bin);
return MD4_CTX_LEN;
case DRV_MD4_UPDATE:
if (len < MD4_CTX_LEN)
return -1;
bin = return_binary(rbuf,rlen,MD4_CTX_LEN);
memcpy(bin, buf, MD4_CTX_LEN);
MD4_Update((MD4_CTX *) bin, buf + MD4_CTX_LEN, len - MD4_CTX_LEN);
return MD4_CTX_LEN;
case DRV_MD4_FINAL:
if (len != MD4_CTX_LEN)
return -1;
memcpy(&md4_ctx, buf, MD4_CTX_LEN); /* XXX Use buf only? */
bin = return_binary(rbuf,rlen,MD4_LEN);
MD4_Final((unsigned char *)bin, &md4_ctx);
return MD4_LEN;
#if SSL_VERSION_0_9_8
case DRV_SHA256:
bin = return_binary(rbuf,rlen,SHA256_LEN);
SHA256(buf, len, bin);
return SHA256_LEN;
case DRV_SHA256_INIT:
bin = return_binary(rbuf,rlen,SHA256_CTX_LEN);
SHA256_Init((SHA256_CTX *)bin);
return SHA256_CTX_LEN;
case DRV_SHA256_UPDATE:
if (len < SHA256_CTX_LEN)
return -1;
bin = return_binary(rbuf,rlen,SHA256_CTX_LEN);
memcpy(bin, buf, SHA256_CTX_LEN);
SHA256_Update((SHA256_CTX *)bin, buf + SHA256_CTX_LEN,
len - SHA256_CTX_LEN);
return SHA256_CTX_LEN;
case DRV_SHA256_FINAL:
if (len != SHA256_CTX_LEN)
return -1;
memcpy(&sha256_ctx, buf, SHA256_CTX_LEN); /* XXX Use buf only? */
bin = return_binary(rbuf,rlen,SHA256_LEN);
SHA256_Final(bin, &sha256_ctx);
return SHA256_LEN;
case DRV_SHA512:
bin = return_binary(rbuf,rlen,SHA512_LEN);
SHA512(buf, len, bin);
return SHA512_LEN;
case DRV_SHA512_INIT:
bin = return_binary(rbuf,rlen,SHA512_CTX_LEN);
SHA512_Init((SHA512_CTX *)bin);
return SHA512_CTX_LEN;
case DRV_SHA512_UPDATE:
if (len < SHA512_CTX_LEN)
return -1;
bin = return_binary(rbuf,rlen,SHA512_CTX_LEN);
memcpy(bin, buf, SHA512_CTX_LEN);
SHA512_Update((SHA512_CTX *)bin, buf + SHA512_CTX_LEN,
len - SHA512_CTX_LEN);
return SHA512_CTX_LEN;
case DRV_SHA512_FINAL:
if (len != SHA512_CTX_LEN)
return -1;
memcpy(&sha512_ctx, buf, SHA512_CTX_LEN); /* XXX Use buf only? */
bin = return_binary(rbuf,rlen,SHA512_LEN));
SHA512_Final(bin, &sha512_ctx);
return SHA512_LEN;
#endif
case DRV_INFO_LIB:
{/* <<DrvVer:8, NameSize:8, Name:NameSize/binary, VerNum:32, VerStr/binary>> */
static const char libname[] = "OpenSSL";
unsigned name_sz = strlen(libname);
const char* ver = SSLeay_version(SSLEAY_VERSION);
unsigned ver_sz = strlen(ver);
dlen = 1+1+name_sz+4+ver_sz;
bin = return_binary(rbuf, rlen, dlen);
if (bin==NULL) return -1;
p = bin;
*p++ = 0; /* "driver version" for future use */
*p++ = name_sz;
memcpy(p, libname, name_sz);
p += name_sz;
put_int32(p,SSLeay()); /* OPENSSL_VERSION_NUMBER */
p += 4;
memcpy(p, ver, ver_sz);
}
return dlen;
default:
break;
}
return -1;
}
#ifdef OPENSSL_THREADS /* vvvvvvvvvvvvvvv OPENSSL_THREADS vvvvvvvvvvvvvvvv */
static INLINE void locking(int mode, ErlDrvRWLock* lock)
{
switch(mode) {
case CRYPTO_LOCK|CRYPTO_READ:
erl_drv_rwlock_rlock(lock);
break;
case CRYPTO_LOCK|CRYPTO_WRITE:
erl_drv_rwlock_rwlock(lock);
break;
case CRYPTO_UNLOCK|CRYPTO_READ:
erl_drv_rwlock_runlock(lock);
break;
case CRYPTO_UNLOCK|CRYPTO_WRITE:
erl_drv_rwlock_rwunlock(lock);
break;
default:
ASSERT(!"Invalid lock mode");
}
}
/* Callback from openssl for static locking
*/
static void locking_function(int mode, int n, const char *file, int line)
{
ASSERT(n>=0 && n<CRYPTO_num_locks());
locking(mode, lock_vec[n]);
}
/* Callback from openssl for thread id
*/
static unsigned long id_function(void)
{
return (unsigned long) erl_drv_thread_self();
}
/* Callbacks for dynamic locking, not used by current openssl version (0.9.8)
*/
static struct CRYPTO_dynlock_value* dyn_create_function(const char *file, int line)
{
return (struct CRYPTO_dynlock_value*) erl_drv_rwlock_create("crypto_drv_dyn");
}
static void dyn_lock_function(int mode, struct CRYPTO_dynlock_value* ptr,const char *file, int line)
{
locking(mode, (ErlDrvRWLock*)ptr);
}
static void dyn_destroy_function(struct CRYPTO_dynlock_value *ptr, const char *file, int line)
{
erl_drv_rwlock_destroy((ErlDrvRWLock*)ptr);
}
#endif /* ^^^^^^^^^^^^^^^^^^^^^^ OPENSSL_THREADS ^^^^^^^^^^^^^^^^^^^^^^ */
/* HMAC */
static void hmac_md5(char *key, int klen, char *dbuf, int dlen, char *hmacbuf)
{
MD5_CTX ctx;
char ipad[HMAC_INT_LEN];
char opad[HMAC_INT_LEN];
unsigned char nkey[MD5_LEN];
int i;
/* Change key if longer than 64 bytes */
if (klen > HMAC_INT_LEN) {
MD5_CTX kctx;
MD5_Init(&kctx);
MD5_Update(&kctx, key, klen);
MD5_Final(nkey, &kctx);
key = (char *) nkey;
klen = MD5_LEN;
}
memset(ipad, '\0', sizeof(ipad));
memset(opad, '\0', sizeof(opad));
memcpy(ipad, key, klen);
memcpy(opad, key, klen);
for (i = 0; i < HMAC_INT_LEN; i++) {
ipad[i] ^= HMAC_IPAD;
opad[i] ^= HMAC_OPAD;
}
/* inner MD5 */
MD5_Init(&ctx);
MD5_Update(&ctx, ipad, HMAC_INT_LEN);
MD5_Update(&ctx, dbuf, dlen);
MD5_Final((unsigned char *) hmacbuf, &ctx);
/* outer MD5 */
MD5_Init(&ctx);
MD5_Update(&ctx, opad, HMAC_INT_LEN);
MD5_Update(&ctx, hmacbuf, MD5_LEN);
MD5_Final((unsigned char *) hmacbuf, &ctx);
}
static void hmac_sha1(char *key, int klen, char *dbuf, int dlen,
char *hmacbuf)
{
SHA_CTX ctx;
char ipad[HMAC_INT_LEN];
char opad[HMAC_INT_LEN];
unsigned char nkey[SHA_LEN];
int i;
/* Change key if longer than 64 bytes */
if (klen > HMAC_INT_LEN) {
SHA_CTX kctx;
SHA1_Init(&kctx);
SHA1_Update(&kctx, key, klen);
SHA1_Final(nkey, &kctx);
key = (char *) nkey;
klen = SHA_LEN;
}
memset(ipad, '\0', sizeof(ipad));
memset(opad, '\0', sizeof(opad));
memcpy(ipad, key, klen);
memcpy(opad, key, klen);
for (i = 0; i < HMAC_INT_LEN; i++) {
ipad[i] ^= HMAC_IPAD;
opad[i] ^= HMAC_OPAD;
}
/* inner SHA */
SHA1_Init(&ctx);
SHA1_Update(&ctx, ipad, HMAC_INT_LEN);
SHA1_Update(&ctx, dbuf, dlen);
SHA1_Final((unsigned char *) hmacbuf, &ctx);
/* outer SHA */
SHA1_Init(&ctx);
SHA1_Update(&ctx, opad, HMAC_INT_LEN);
SHA1_Update(&ctx, hmacbuf, SHA_LEN);
SHA1_Final((unsigned char *) hmacbuf, &ctx);
}
