luban-lite/bsp/peripheral/wireless/atbm603x/net/wpa/crypto/sha256.c

/*
 * SHA-256 hash implementation and interface functions
 * Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "atbm_hal.h"

/**
 * atbmwifi_hmac_sha256_vector - HMAC-SHA256 over data vector (RFC 2104)
 * @key: Key for HMAC operations
 * @key_len: Length of the key in bytes
 * @num_elem: Number of elements in the data vector
 * @addr: Pointers to the data areas
 * @len: Lengths of the data blocks
 * @mac: Buffer for the hash (32 bytes)
 * Returns: 0 on success, -1 on failure
 */
int atbmwifi_hmac_sha256_vector(const atbm_uint8 *key, atbm_size_t key_len, atbm_size_t num_elem,
		       const atbm_uint8 *addr[], const atbm_size_t *len, atbm_uint8 *mac)
{
	atbm_uint8 k_pad[64]; /* padding - key XORd with ipad/opad */
	atbm_uint8 tk[32];
	const atbm_uint8 *_addr[6];
	atbm_size_t _len[6], i;

	if (num_elem > 5) {
		/*
		 * Fixed limit on the number of fragments to avoid having to
		 * allocate memory (which could fail).
		 */
		return -1;
	}

        /* if key is longer than 64 bytes reset it to key = SHA256(key) */
        if (key_len > 64) {
		if (atbmwifi_sha256_vector(1, &key, &key_len, tk) < 0)
			return -1;
		key = tk;
		key_len = 32;
        }

	/* the HMAC_SHA256 transform looks like:
	 *
	 * SHA256(K XOR opad, SHA256(K XOR ipad, text))
	 *
	 * where K is an n byte key
	 * ipad is the byte 0x36 repeated 64 times
	 * opad is the byte 0x5c repeated 64 times
	 * and text is the data being protected */

	/* start out by storing key in ipad */
	atbm_memset(k_pad, 0, sizeof(k_pad));
	atbm_memcpy(k_pad, key, key_len);
	/* XOR key with ipad values */
	for (i = 0; i < 64; i++)
		k_pad[i] ^= 0x36;

	/* perform inner SHA256 */
	_addr[0] = k_pad;
	_len[0] = 64;
	for (i = 0; i < num_elem; i++) {
		_addr[i + 1] = addr[i];
		_len[i + 1] = len[i];
	}
	if (atbmwifi_sha256_vector(1 + num_elem, _addr, _len, mac) < 0)
		return -1;

	atbm_memset(k_pad, 0, sizeof(k_pad));
	atbm_memcpy(k_pad, key, key_len);
	/* XOR key with opad values */
	for (i = 0; i < 64; i++)
		k_pad[i] ^= 0x5c;

	/* perform outer SHA256 */
	_addr[0] = k_pad;
	_len[0] = 64;
	_addr[1] = mac;
	_len[1] = SHA256_MAC_LEN;
	return atbmwifi_sha256_vector(2, _addr, _len, mac);
}


/**
 * atbmwifi_hmac_sha256 - HMAC-SHA256 over data buffer (RFC 2104)
 * @key: Key for HMAC operations
 * @key_len: Length of the key in bytes
 * @data: Pointers to the data area
 * @data_len: Length of the data area
 * @mac: Buffer for the hash (32 bytes)
 * Returns: 0 on success, -1 on failure
 */
int atbmwifi_hmac_sha256(const atbm_uint8 *key, atbm_size_t key_len, const atbm_uint8 *data,
		atbm_size_t data_len, atbm_uint8 *mac)
{
	return atbmwifi_hmac_sha256_vector(key, key_len, 1, &data, &data_len, mac);
}

/**
 * sha256_prf - SHA256-based Pseudo-Random Function (IEEE 802.11r, 8.5.1.5.2)
 * @key: Key for PRF
 * @key_len: Length of the key in bytes
 * @label: A unique label for each purpose of the PRF
 * @data: Extra data to bind into the key
 * @data_len: Length of the data
 * @buf: Buffer for the generated pseudo-random key
 * @buf_len: Number of bytes of key to generate
 * Returns: 0 on success, -1 on failure
 *
 * This function is used to derive new, cryptographically separate keys from a
 * given key.
 */
int atbmwifi_sha256_prf(const atbm_uint8 *key, atbm_size_t key_len, const char *label,
		const atbm_uint8 *data, atbm_size_t data_len, atbm_uint8 *buf, atbm_size_t buf_len)
{
	return atbmwifi_sha256_prf_bits(key, key_len, label, data, data_len, buf,
				   buf_len * 8);
}


/**
 * sha256_prf_bits - IEEE Std 802.11-2012, 11.6.1.7.2 Key derivation function
 * @key: Key for KDF
 * @key_len: Length of the key in bytes
 * @label: A unique label for each purpose of the PRF
 * @data: Extra data to bind into the key
 * @data_len: Length of the data
 * @buf: Buffer for the generated pseudo-random key
 * @buf_len: Number of bits of key to generate
 * Returns: 0 on success, -1 on failure
 *
 * This function is used to derive new, cryptographically separate keys from a
 * given key. If the requested buf_len is not divisible by eight, the least
 * significant 1-7 bits of the last octet in the output are not part of the
 * requested output.
 */
int atbmwifi_sha256_prf_bits(const atbm_uint8 *key, atbm_size_t key_len, const char *label,
			const atbm_uint8 *data, atbm_size_t data_len, atbm_uint8 *buf,
			atbm_size_t buf_len_bits)
{
	atbm_uint16 counter = 1;
	atbm_size_t pos, plen;
	atbm_uint8 hash[SHA256_MAC_LEN];
	const atbm_uint8 *addr[4];
	atbm_size_t len[4];
	atbm_uint8 counter_le[2], length_le[2];
	atbm_size_t buf_len = (buf_len_bits + 7) / 8;

	addr[0] = counter_le;
	len[0] = 2;
	addr[1] = (atbm_uint8 *) label;
	len[1] = strlen(label);
	addr[2] = data;
	len[2] = data_len;
	addr[3] = length_le;
	len[3] = sizeof(length_le);

	ATBM_WPA_PUT_LE16(length_le, buf_len_bits);
	pos = 0;
	while (pos < buf_len) {
		plen = buf_len - pos;
		ATBM_WPA_PUT_LE16(counter_le, counter);
		if (plen >= SHA256_MAC_LEN) {
			if (atbmwifi_hmac_sha256_vector(key, key_len, 4, addr, len,
						   &buf[pos]) < 0)
				return -1;
			pos += SHA256_MAC_LEN;
		} else {
			if (atbmwifi_hmac_sha256_vector(key, key_len, 4, addr, len,
						   hash) < 0)
				return -1;
			atbm_memcpy(&buf[pos], hash, plen);
			pos += plen;
			break;
		}
		counter++;
	}

	/*
	 * Mask out unused bits in the last octet if it does not use all the
	 * bits.
	 */
	if (buf_len_bits % 8) {
		atbm_uint8 mask = 0xff << (8 - buf_len_bits % 8);
		buf[pos - 1] &= mask;
	}

	atbm_memset(hash, 0, sizeof(hash));

	return 0;
}