File Manager

003 File Manager

Current Path: /usr/src/contrib/wpa/src/crypto

usr / src / contrib / wpa / src / crypto /

📁 ..
📄 aes-cbc.c(1.93 KB)
📄 aes-ccm.c(4.92 KB)
📄 aes-ctr.c(1.64 KB)
📄 aes-eax.c(3.24 KB)
📄 aes-encblock.c(704 B)
📄 aes-gcm.c(6.47 KB)
📄 aes-internal-dec.c(3.64 KB)
📄 aes-internal-enc.c(2.66 KB)
📄 aes-internal.c(41.23 KB)
📄 aes-omac1.c(4.46 KB)
📄 aes-siv.c(4.06 KB)
📄 aes-unwrap.c(1.78 KB)
📄 aes-wrap.c(1.62 KB)
📄 aes.h(548 B)
📄 aes_i.h(4.16 KB)
📄 aes_siv.h(565 B)
📄 aes_wrap.h(2.91 KB)
📄 crypto.h(28.61 KB)
📄 crypto_gnutls.c(11.42 KB)
📄 crypto_internal-cipher.c(5.08 KB)
📄 crypto_internal-modexp.c(2.95 KB)
📄 crypto_internal-rsa.c(2.81 KB)
📄 crypto_internal.c(6.84 KB)
📄 crypto_libtomcrypt.c(15.07 KB)
📄 crypto_linux.c(21.77 KB)
📄 crypto_module_tests.c(61.19 KB)
📄 crypto_nettle.c(9.7 KB)
📄 crypto_none.c(461 B)
📄 crypto_openssl.c(44.34 KB)
📄 crypto_wolfssl.c(33.91 KB)
📄 des-internal.c(14.83 KB)
📄 des_i.h(709 B)
📄 dh_group5.c(806 B)
📄 dh_group5.h(556 B)
📄 dh_groups.c(54.26 KB)
📄 dh_groups.h(692 B)
📄 fips_prf_internal.c(1.37 KB)
📄 fips_prf_openssl.c(2.05 KB)
📄 fips_prf_wolfssl.c(1.75 KB)
📄 md4-internal.c(7.91 KB)
📄 md5-internal.c(8.79 KB)
📄 md5.c(2.64 KB)
📄 md5.h(505 B)
📄 md5_i.h(516 B)
📄 milenage.c(9.5 KB)
📄 milenage.h(1019 B)
📄 ms_funcs.c(16.16 KB)
📄 ms_funcs.h(2.41 KB)
📄 random.c(11.66 KB)
📄 random.h(855 B)
📄 rc4.c(1009 B)
📄 sha1-internal.c(8.93 KB)
📄 sha1-pbkdf2.c(2.34 KB)
📄 sha1-prf.c(1.58 KB)
📄 sha1-tlsprf.c(2.69 KB)
📄 sha1-tprf.c(1.75 KB)
📄 sha1.c(2.69 KB)
📄 sha1.h(1.03 KB)
📄 sha1_i.h(590 B)
📄 sha256-internal.c(6 KB)
📄 sha256-kdf.c(2.08 KB)
📄 sha256-prf.c(2.84 KB)
📄 sha256-tlsprf.c(1.81 KB)
📄 sha256.c(2.64 KB)
📄 sha256.h(1.07 KB)
📄 sha256_i.h(584 B)
📄 sha384-internal.c(2.17 KB)
📄 sha384-kdf.c(2.08 KB)
📄 sha384-prf.c(2.85 KB)
📄 sha384.c(2.63 KB)
📄 sha384.h(949 B)
📄 sha384_i.h(573 B)
📄 sha512-internal.c(7.71 KB)
📄 sha512-kdf.c(2.08 KB)
📄 sha512-prf.c(2.85 KB)
📄 sha512.c(2.63 KB)
📄 sha512.h(949 B)
📄 sha512_i.h(591 B)
📄 tls.h(23.71 KB)
📄 tls_gnutls.c(44.97 KB)
📄 tls_internal.c(18.93 KB)
📄 tls_none.c(3.9 KB)
📄 tls_openssl.c(137.99 KB)
📄 tls_openssl.h(477 B)
📄 tls_openssl_ocsp.c(20.52 KB)
📄 tls_wolfssl.c(51.88 KB)

Editing: crypto_internal-cipher.c

/*
 * Crypto wrapper for internal crypto implementation - Cipher wrappers
 * Copyright (c) 2006-2009, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "includes.h"

#include "common.h"
#include "crypto.h"
#include "aes.h"
#include "des_i.h"

struct crypto_cipher {
	enum crypto_cipher_alg alg;
	union {
		struct {
			size_t used_bytes;
			u8 key[16];
			size_t keylen;
		} rc4;
		struct {
			u8 cbc[32];
			void *ctx_enc;
			void *ctx_dec;
		} aes;
		struct {
			struct des3_key_s key;
			u8 cbc[8];
		} des3;
		struct {
			u32 ek[32];
			u32 dk[32];
			u8 cbc[8];
		} des;
	} u;
};

struct crypto_cipher * crypto_cipher_init(enum crypto_cipher_alg alg,
					  const u8 *iv, const u8 *key,
					  size_t key_len)
{
	struct crypto_cipher *ctx;

ctx = os_zalloc(sizeof(*ctx));
	if (ctx == NULL)
		return NULL;

ctx->alg = alg;

switch (alg) {
	case CRYPTO_CIPHER_ALG_RC4:
		if (key_len > sizeof(ctx->u.rc4.key)) {
			os_free(ctx);
			return NULL;
		}
		ctx->u.rc4.keylen = key_len;
		os_memcpy(ctx->u.rc4.key, key, key_len);
		break;
	case CRYPTO_CIPHER_ALG_AES:
		ctx->u.aes.ctx_enc = aes_encrypt_init(key, key_len);
		if (ctx->u.aes.ctx_enc == NULL) {
			os_free(ctx);
			return NULL;
		}
		ctx->u.aes.ctx_dec = aes_decrypt_init(key, key_len);
		if (ctx->u.aes.ctx_dec == NULL) {
			aes_encrypt_deinit(ctx->u.aes.ctx_enc);
			os_free(ctx);
			return NULL;
		}
		os_memcpy(ctx->u.aes.cbc, iv, AES_BLOCK_SIZE);
		break;
	case CRYPTO_CIPHER_ALG_3DES:
		if (key_len != 24) {
			os_free(ctx);
			return NULL;
		}
		des3_key_setup(key, &ctx->u.des3.key);
		os_memcpy(ctx->u.des3.cbc, iv, 8);
		break;
	case CRYPTO_CIPHER_ALG_DES:
		if (key_len != 8) {
			os_free(ctx);
			return NULL;
		}
		des_key_setup(key, ctx->u.des.ek, ctx->u.des.dk);
		os_memcpy(ctx->u.des.cbc, iv, 8);
		break;
	default:
		os_free(ctx);
		return NULL;
	}

return ctx;
}

int crypto_cipher_encrypt(struct crypto_cipher *ctx, const u8 *plain,
			  u8 *crypt, size_t len)
{
	size_t i, j, blocks;

switch (ctx->alg) {
	case CRYPTO_CIPHER_ALG_RC4:
		if (plain != crypt)
			os_memcpy(crypt, plain, len);
		rc4_skip(ctx->u.rc4.key, ctx->u.rc4.keylen,
			 ctx->u.rc4.used_bytes, crypt, len);
		ctx->u.rc4.used_bytes += len;
		break;
	case CRYPTO_CIPHER_ALG_AES:
		if (len % AES_BLOCK_SIZE)
			return -1;
		blocks = len / AES_BLOCK_SIZE;
		for (i = 0; i < blocks; i++) {
			for (j = 0; j < AES_BLOCK_SIZE; j++)
				ctx->u.aes.cbc[j] ^= plain[j];
			aes_encrypt(ctx->u.aes.ctx_enc, ctx->u.aes.cbc,
				    ctx->u.aes.cbc);
			os_memcpy(crypt, ctx->u.aes.cbc, AES_BLOCK_SIZE);
			plain += AES_BLOCK_SIZE;
			crypt += AES_BLOCK_SIZE;
		}
		break;
	case CRYPTO_CIPHER_ALG_3DES:
		if (len % 8)
			return -1;
		blocks = len / 8;
		for (i = 0; i < blocks; i++) {
			for (j = 0; j < 8; j++)
				ctx->u.des3.cbc[j] ^= plain[j];
			des3_encrypt(ctx->u.des3.cbc, &ctx->u.des3.key,
				     ctx->u.des3.cbc);
			os_memcpy(crypt, ctx->u.des3.cbc, 8);
			plain += 8;
			crypt += 8;
		}
		break;
	case CRYPTO_CIPHER_ALG_DES:
		if (len % 8)
			return -1;
		blocks = len / 8;
		for (i = 0; i < blocks; i++) {
			for (j = 0; j < 8; j++)
				ctx->u.des3.cbc[j] ^= plain[j];
			des_block_encrypt(ctx->u.des.cbc, ctx->u.des.ek,
					  ctx->u.des.cbc);
			os_memcpy(crypt, ctx->u.des.cbc, 8);
			plain += 8;
			crypt += 8;
		}
		break;
	default:
		return -1;
	}

return 0;
}

int crypto_cipher_decrypt(struct crypto_cipher *ctx, const u8 *crypt,
			  u8 *plain, size_t len)
{
	size_t i, j, blocks;
	u8 tmp[32];

switch (ctx->alg) {
	case CRYPTO_CIPHER_ALG_RC4:
		if (plain != crypt)
			os_memcpy(plain, crypt, len);
		rc4_skip(ctx->u.rc4.key, ctx->u.rc4.keylen,
			 ctx->u.rc4.used_bytes, plain, len);
		ctx->u.rc4.used_bytes += len;
		break;
	case CRYPTO_CIPHER_ALG_AES:
		if (len % AES_BLOCK_SIZE)
			return -1;
		blocks = len / AES_BLOCK_SIZE;
		for (i = 0; i < blocks; i++) {
			os_memcpy(tmp, crypt, AES_BLOCK_SIZE);
			aes_decrypt(ctx->u.aes.ctx_dec, crypt, plain);
			for (j = 0; j < AES_BLOCK_SIZE; j++)
				plain[j] ^= ctx->u.aes.cbc[j];
			os_memcpy(ctx->u.aes.cbc, tmp, AES_BLOCK_SIZE);
			plain += AES_BLOCK_SIZE;
			crypt += AES_BLOCK_SIZE;
		}
		break;
	case CRYPTO_CIPHER_ALG_3DES:
		if (len % 8)
			return -1;
		blocks = len / 8;
		for (i = 0; i < blocks; i++) {
			os_memcpy(tmp, crypt, 8);
			des3_decrypt(crypt, &ctx->u.des3.key, plain);
			for (j = 0; j < 8; j++)
				plain[j] ^= ctx->u.des3.cbc[j];
			os_memcpy(ctx->u.des3.cbc, tmp, 8);
			plain += 8;
			crypt += 8;
		}
		break;
	case CRYPTO_CIPHER_ALG_DES:
		if (len % 8)
			return -1;
		blocks = len / 8;
		for (i = 0; i < blocks; i++) {
			os_memcpy(tmp, crypt, 8);
			des_block_decrypt(crypt, ctx->u.des.dk, plain);
			for (j = 0; j < 8; j++)
				plain[j] ^= ctx->u.des.cbc[j];
			os_memcpy(ctx->u.des.cbc, tmp, 8);
			plain += 8;
			crypt += 8;
		}
		break;
	default:
		return -1;
	}

return 0;
}

void crypto_cipher_deinit(struct crypto_cipher *ctx)
{
	switch (ctx->alg) {
	case CRYPTO_CIPHER_ALG_AES:
		aes_encrypt_deinit(ctx->u.aes.ctx_enc);
		aes_decrypt_deinit(ctx->u.aes.ctx_dec);
		break;
	case CRYPTO_CIPHER_ALG_3DES:
		break;
	default:
		break;
	}
	os_free(ctx);
}

003 File Manager

Editing: crypto_internal-cipher.c

Upload File

Create Folder