Beginnings of a crypto abstraction layer. (5af5a963) · Commits · Gaba / Tor

src/common/crypto.c

0 → 100644

+245 −0

Original line number	Diff line number	Diff line
		/* Copyright 2001,2002 Roger Dingledine, Matej Pfajfar. */
		/* See LICENSE for licensing information */
		/* $Id$ */

		#include "crypto.h"

		#include <stdlib.h>

		int crypto_global_init()
		{
		ERR_load_crypto_strings();
		return 0;
		}

		int crypto_global_cleanup()
		{
		ERR_free_strings();
		return 0;
		}

		crypto_pk_env_t *crypto_new_pk_env(int type)
		{
		crypto_pk_env_t *env;

		env = (crypto_pk_env_t *)malloc(sizeof(crypto_pk_env_t));
		if (!env)
		return 0;

		env->type = type;
		env->key = NULL;
		env->aux = NULL;

		switch(type) {
		case CRYPTO_PK_RSA:
		env->key = (unsigned char *)RSA_new();
		if (!env->key) {
		free((void *)env);
		return NULL;
		}
		break;
		default:
		free((void *)env);
		return NULL;
		break;
		}

		return env;
		}

		void crypto_free_pk_env(crypto_pk_env_t *env)
		{
		if (!env)
		return;

		switch(env->type) {
		case CRYPTO_PK_RSA:
		if (env->key)
		RSA_free((RSA *)env->key);
		break;
		default:
		break;
		}

		free((void *)env);
		return;
		}

		crypto_cipher_env_t *crypto_new_cipher_env(int type)
		{
		crypto_cipher_env_t *env;

		env = (crypto_cipher_env_t *)malloc(sizeof(crypto_cipher_env_t));
		if (!env)
		return NULL;

		env->type = type;
		env->key = NULL;
		env->iv = NULL;
		env->aux = NULL;

		switch(type) {
		case CRYPTO_CIPHER_IDENTITY:
		env->aux = (unsigned char *)malloc(sizeof(EVP_CIPHER_CTX));
		if (!env->aux) {
		free((void *)env);
		return NULL;
		}
		EVP_CIPHER_CTX_init((EVP_CIPHER_CTX *)env->aux);
		break;
		case CRYPTO_CIPHER_DES:
		env->aux = (unsigned char *)malloc(sizeof(EVP_CIPHER_CTX));
		if (!env->aux) {
		free((void *)env);
		return NULL;
		}
		env->key = (unsigned char *)malloc(8);
		if (!env->key) {
		free((void *)env->aux);
		free((void *)env);
		return NULL;
		}
		env->iv = (unsigned char *)malloc(8);
		if (!env->iv) {
		free((void *)env->key);
		free((void *)env->aux);
		return NULL;
		}
		EVP_CIPHER_CTX_init((EVP_CIPHER_CTX *)env->aux);
		break;
		case CRYPTO_CIPHER_RC4:
		env->aux = (unsigned char *)malloc(sizeof(EVP_CIPHER_CTX));
		if (!env->aux) {
		free((void *)env);
		return NULL;
		}
		env->key = (unsigned char *)malloc(16);
		if (!env->key) {
		free((void *)env->aux);
		free((void *)env);
		return NULL;
		}
		env->iv = (unsigned char *)malloc(16);
		if (!env->iv) {
		free((void *)env->key);
		free((void *)env->aux);
		return NULL;
		}
		break;
		EVP_CIPHER_CTX_init((EVP_CIPHER_CTX *)env->aux);
		default:
		free((void *)env);
		return NULL;
		break;
		}

		return env;
		}

		void crypto_free_cipher_env(crypto_cipher_env_t *env)
		{
		if (!env)
		return;

		switch(env->type) {
		case CRYPTO_CIPHER_IDENTITY:
		if (env->aux) {
		EVP_CIPHER_CTX_cleanup((EVP_CIPHER_CTX *)env->aux);
		free((void *)env->aux);
		}
		break;
		case CRYPTO_CIPHER_DES:
		if (env->aux) {
		EVP_CIPHER_CTX_cleanup((EVP_CIPHER_CTX *)env->aux);
		free((void *)env->aux);
		}
		if (env->key)
		free((void *)env->key);
		if (env->iv)
		free((void *)env->iv);
		break;
		case CRYPTO_CIPHER_RC4:
		if (env->aux) {
		EVP_CIPHER_CTX_cleanup((EVP_CIPHER_CTX *)env->aux);
		free((void *)env->aux);
		}
		if (env->key)
		free((void *)env->key);
		if (env->iv)
		free((void *)env->iv);
		break;
		default:
		break;
		}

		free((void *)env);
		return;
		}

		/* public key crypto */
		int crypto_pk_generate_key(crypto_pk_env_t *env)
		{
		return 0;
		}

		int crypto_pk_read_private_key(crypto_pk_env_t env, FILE src)
		{
		return 0;
		}
		int crypto_pk_read_public_key(crypto_pk_env_t env, FILE src)
		{
		return 0;
		}
		int crypto_pk_write_private_key(crypto_pk_env_t env, FILE dest)
		{
		return 0;
		}
		int crypto_pk_write_public_key(crypto_pk_env_t env, FILE dest)
		{
		return 0;
		}

		int crypto_pk_set_key(crypto_pk_env_t env, unsigned char key)
		{
		return 0;
		}

		/* symmetric crypto */
		int crypto_cipher_set_iv(crypto_cipher_env_t env, unsigned char iv)
		{
		return 0;
		}
		int crypto_cipher_set_key(crypto_cipher_env_t env, unsigned char key)
		{
		return 0;
		}
		int crypto_cipher_init_cipher()
		{
		return 0;
		}

		int crypto_cipher_encrypt(crypto_cipher_env_t env, unsigned char from, unsigned int fromlen, unsigned char *to)
		{
		return 0;
		}

		int crypto_cipher_decrypt(crypto_cipher_env_t env, unsigned char from, unsigned int fromlen, unsigned char *to)
		{
		return 0;
		}

		/* SHA-1 */
		int crypto_SHA_digest(unsigned char m, unsigned char digest)
		{
		return 0;
		}

		/* random numbers */
		int crypto_rand(unsigned int n, unsigned char *to)
		{
		return 0;
		}
		int crypto_pseudo_rand(unsigned int n, unsigned char *to)
		{
		return 0;
		}

src/common/crypto.h

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		/* Copyright 2001,2002 Roger Dingledine, Matej Pfajfar. */
		/* See LICENSE for licensing information */
		/* $Id$ */

		#ifndef __CRYPTO_H
		#define __CRYPTO_H

		#include <openssl/err.h>
		#include <openssl/rsa.h>
		#include <openssl/pem.h>
		#include <openssl/evp.h>
		#include <openssl/rand.h>

		/* available encryption primitives */
		#define CRYPTO_CIPHER_IDENTITY 0
		#define CRYPTO_CIPHER_DES 1
		#define CRYPTO_CIPHER_RC4 2

		#define CRYPTO_PK_RSA 0

		typedef struct
		{
		int type;
		unsigned char *key;
		/* auxiliary data structure(s) used by the underlying crypto library */
		unsigned char *aux;
		} crypto_pk_env_t;

		typedef struct
		{
		int type;
		unsigned char *key;
		unsigned char *iv;
		/* auxiliary data structure(s) used by the underlying crypto library */
		unsigned char *aux;
		} crypto_cipher_env_t;

		/* global state */
		int crypto_global_init();
		int crypto_global_cleanup();

		/* environment setup */
		crypto_pk_env_t *crypto_new_pk_env(int type);
		void crypto_free_pk_env(crypto_pk_env_t *env);

		crypto_cipher_env_t *crypto_new_cipher_env(int type);
		void crypto_free_cipher_env(crypto_cipher_env_t *env);

		/* public key crypto */
		int crypto_pk_generate_key(crypto_pk_env_t *env);

		int crypto_pk_read_private_key(crypto_pk_env_t env, FILE src);
		int crypto_pk_read_public_key(crypto_pk_env_t env, FILE src);
		int crypto_pk_write_private_key(crypto_pk_env_t env, FILE dest);
		int crypto_pk_write_public_key(crypto_pk_env_t env, FILE dest);

		int crypto_pk_set_key(crypto_pk_env_t env, unsigned char key);

		/* symmetric crypto */
		int crypto_cipher_set_iv(crypto_cipher_env_t env, unsigned char iv);
		int crypto_cipher_set_key(crypto_cipher_env_t env, unsigned char key);
		int crypto_cipher_init_cipher();

		int crypto_cipher_encrypt(crypto_cipher_env_t env, unsigned char from, unsigned int fromlen, unsigned char *to);
		int crypto_cipher_decrypt(crypto_cipher_env_t env, unsigned char from, unsigned int fromlen, unsigned char *to);

		/* SHA-1 */
		int crypto_SHA_digest(unsigned char m, unsigned char digest);

		/* random numbers */
		int crypto_rand(unsigned int n, unsigned char *to);
		int crypto_pseudo_rand(unsigned int n, unsigned char *to);

		#endif