← Commit list

abbf17abc

Denys Vlasenko

2017-01-20

SUCCESS Duration: 244s

Subject

tls: add the i/o loop - largish rework of i/o buffering

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

networking/tls.c +166 -108

networking/tls.c+166 -108

@@ -23,9 +23,10 @@
	//usage:#define tls_full_usage "\n\n"

	#include "tls.h"
+	#include "common_bufsiz.h"

	#define TLS_DEBUG 1
-	#define TLS_DEBUG_HASH 0
+	#define TLS_DEBUG_HASH 1
	#define TLS_DEBUG_DER 0

	#if TLS_DEBUG
@@ -150,9 +151,8 @@
	// works against "openssl s_server -cipher NULL"
	// and against wolfssl-3.9.10-stable/examples/server/server.c:
	//#define CIPHER_ID TLS_RSA_WITH_NULL_SHA256 // for testing (does everything except encrypting)
-	// "works", meaning
-	// "can send encrypted FINISHED to wolfssl-3.9.10-stable/examples/server/server.c",
-	// don't yet read its encrypted answers:
+	// works against wolfssl-3.9.10-stable/examples/server/server.c
+	// (getting back and decrypt ok first application data message)
	#define CIPHER_ID TLS_RSA_WITH_AES_256_CBC_SHA256 // ok, no SERVER_KEY_EXCHANGE

	enum {
@@ -162,6 +162,11 @@ enum {
	AES_BLOCKSIZE = 16,
	AES128_KEYSIZE = 16,
	AES256_KEYSIZE = 32,
+
+	MAX_TLS_RECORD = (1 << 14),
+	OUTBUF_PFX = 8 + AES_BLOCKSIZE, /* header + IV */
+	OUTBUF_SFX = SHA256_OUTSIZE + AES_BLOCKSIZE, /* MAC + padding */
+	MAX_OTBUF = MAX_TLS_RECORD - OUTBUF_PFX - OUTBUF_SFX,
	};

	struct record_hdr {
@@ -195,6 +200,9 @@ typedef struct tls_state {
	// exceed 2^64-1.
	uint64_t write_seq64_be;

+	int outbuf_size;
+	uint8_t *outbuf;
+
	// RFC 5246
	// \|6.2.1. Fragmentation
	// \| The record layer fragments information blocks into TLSPlaintext
@@ -225,7 +233,6 @@ typedef struct tls_state {
	//needed?
	uint64_t align____;
	uint8_t inbuf[20*1024];
-	uint8_t outbuf[20*1024];
	} tls_state_t;


@@ -462,6 +469,17 @@ static void tls_error_die(tls_state_t *tls)
	xfunc_die();
	}

+	static void tls_get_outbuf(tls_state_t tls, int len)
+	{
+	if (len > MAX_OTBUF)
+	xfunc_die();
+	if (tls->outbuf_size < len + OUTBUF_PFX + OUTBUF_SFX) {
+	tls->outbuf_size = len + OUTBUF_PFX + OUTBUF_SFX;
+	tls->outbuf = xrealloc(tls->outbuf, tls->outbuf_size);
+	}
+	return tls->outbuf + OUTBUF_PFX;
+	}
+
	// RFC 5246
	// 6.2.3.1. Null or Standard Stream Cipher
	//
@@ -501,39 +519,41 @@ static void tls_error_die(tls_state_t *tls)
	// -------- ----------- ---------- --------------
	// SHA HMAC-SHA1 20 20
	// SHA256 HMAC-SHA256 32 32
-	static void xwrite_and_hash(tls_state_t tls, /const/ void buf, unsigned size)
+	static void xwrite_encrypted(tls_state_t *tls, unsigned size, unsigned type)
	{
-	uint8_t mac_hash[SHA256_OUTSIZE];
-	struct record_hdr *xhdr = buf;
+	uint8_t *buf = tls->outbuf + OUTBUF_PFX;
+	struct record_hdr *xhdr;

-	if (!tls->encrypt_on_write) {
-	xwrite(tls->fd, buf, size);
-	dbg("wrote %u bytes\n", size);
-	/* Handshake hash does not include record headers */
-	if (size > 5 && xhdr->type == RECORD_TYPE_HANDSHAKE) {
-	sha256_hash_dbg(">> sha256:%s", &tls->handshake_sha256_ctx, (uint8_t*)buf + 5, size - 5);
-	}
-	return;
-	}
+	xhdr = (void)(buf - sizeof(xhdr));
+	if (CIPHER_ID != TLS_RSA_WITH_NULL_SHA256)
+	xhdr = (void)(buf - sizeof(xhdr) - AES_BLOCKSIZE); /* place for IV */
+
+	xhdr->type = type;
+	xhdr->proto_maj = TLS_MAJ;
+	xhdr->proto_min = TLS_MIN;
+	/* fake unencrypted record header len for MAC calculation */
+	xhdr->len16_hi = size >> 8;
+	xhdr->len16_lo = size & 0xff;

+	/* Calculate MAC signature */
	//TODO: convert hmac_sha256 to precomputed
-	hmac_sha256(mac_hash,
+	hmac_sha256(buf + size,
	tls->client_write_MAC_key, sizeof(tls->client_write_MAC_key),
	&tls->write_seq64_be, sizeof(tls->write_seq64_be),
+	xhdr, sizeof(*xhdr),
	buf, size,
	NULL);
	tls->write_seq64_be = SWAP_BE64(1 + SWAP_BE64(tls->write_seq64_be));

+	size += SHA256_OUTSIZE;
+
	if (CIPHER_ID == TLS_RSA_WITH_NULL_SHA256) {
	/* No encryption, only signing */
-	xhdr->len16_lo += SHA256_OUTSIZE;
-	//FIXME: overflow into len16_hi?
-	xwrite(tls->fd, buf, size);
-	xhdr->len16_lo -= SHA256_OUTSIZE;
-	dbg("wrote %u bytes\n", size);
-
-	xwrite(tls->fd, mac_hash, sizeof(mac_hash));
-	dbg("wrote %u bytes of hash\n", (int)sizeof(mac_hash));
+	xhdr->len16_hi = size >> 8;
+	xhdr->len16_lo = size & 0xff;
+	dump_hex(">> %s\n", xhdr, sizeof(*xhdr) + size);
+	xwrite(tls->fd, xhdr, sizeof(*xhdr) + size);
+	dbg("wrote %u bytes (NULL crypt, SHA256 hash)\n", size);
	return;
	}

@@ -579,13 +599,8 @@ static void xwrite_and_hash(tls_state_t tls, /const/ void buf, unsigned size
	uint8_t padding_length;

	/* Build IV+content+MAC+padding in outbuf */
-	tls_get_random(tls->outbuf, AES_BLOCKSIZE); /* IV */
-	p = tls->outbuf + AES_BLOCKSIZE;
-	size -= sizeof(*xhdr);
-	dbg("before crypt: 5 hdr + %u data + %u hash bytes\n", size, (int)sizeof(mac_hash));
-	p = mempcpy(p, buf + sizeof(xhdr), size); / content */
-	p = mempcpy(p, mac_hash, sizeof(mac_hash)); /* MAC */
-	size += sizeof(mac_hash);
+	tls_get_random(buf - AES_BLOCKSIZE, AES_BLOCKSIZE); /* IV */
+	dbg("before crypt: 5 hdr + %u data + %u hash bytes\n", size, SHA256_OUTSIZE);
	// RFC is talking nonsense:
	// Padding that is added to force the length of the plaintext to be
	// an integral multiple of the block cipher's block length.
@@ -601,6 +616,7 @@ static void xwrite_and_hash(tls_state_t tls, /const/ void buf, unsigned size
	// If you need no bytes to reach BLOCKSIZE, you have to pad a full
	// BLOCKSIZE with bytes of value (BLOCKSIZE-1).
	// It's ok to have more than minimum padding, but we do minimum.
+	p = buf + size;
	padding_length = (~size) & (AES_BLOCKSIZE - 1);
	do {
	p++ = padding_length; / padding */
@@ -608,12 +624,12 @@ static void xwrite_and_hash(tls_state_t tls, /const/ void buf, unsigned size
	} while ((size & (AES_BLOCKSIZE - 1)) != 0);

	/* Encrypt content+MAC+padding in place */
-	psAesInit(&ctx, tls->outbuf, /* IV */
+	psAesInit(&ctx, buf - AES_BLOCKSIZE, /* IV */
	tls->client_write_key, sizeof(tls->client_write_key)
	);
	psAesEncrypt(&ctx,
-	tls->outbuf + AES_BLOCKSIZE, /* plaintext */
-	tls->outbuf + AES_BLOCKSIZE, /* ciphertext */
+	buf, /* plaintext */
+	buf, /* ciphertext */
	size
	);

@@ -623,14 +639,33 @@ static void xwrite_and_hash(tls_state_t tls, /const/ void buf, unsigned size
	size += AES_BLOCKSIZE; /* + IV */
	xhdr->len16_hi = size >> 8;
	xhdr->len16_lo = size & 0xff;
-	xwrite(tls->fd, xhdr, sizeof(*xhdr));
-	xwrite(tls->fd, tls->outbuf, size);
+	dump_hex(">> %s\n", xhdr, sizeof(*xhdr) + size);
+	xwrite(tls->fd, xhdr, sizeof(*xhdr) + size);
	dbg("wrote %u bytes\n", (int)sizeof(*xhdr) + size);
-	//restore xhdr->len16_hi = ;
-	//restore xhdr->len16_lo = ;
	}
	}

+	static void xwrite_and_update_handshake_hash(tls_state_t *tls, unsigned size)
+	{
+	if (!tls->encrypt_on_write) {
+	uint8_t *buf = tls->outbuf + OUTBUF_PFX;
+	struct record_hdr xhdr = (void)(buf - sizeof(*xhdr));
+
+	xhdr->type = RECORD_TYPE_HANDSHAKE;
+	xhdr->proto_maj = TLS_MAJ;
+	xhdr->proto_min = TLS_MIN;
+	xhdr->len16_hi = size >> 8;
+	xhdr->len16_lo = size & 0xff;
+	dump_hex(">> %s\n", xhdr, sizeof(*xhdr) + size);
+	xwrite(tls->fd, xhdr, sizeof(*xhdr) + size);
+	dbg("wrote %u bytes\n", (int)sizeof(*xhdr) + size);
+	/* Handshake hash does not include record headers */
+	sha256_hash_dbg(">> sha256:%s", &tls->handshake_sha256_ctx, buf, size);
+	return;
+	}
+	xwrite_encrypted(tls, size, RECORD_TYPE_HANDSHAKE);
+	}
+
	static int xread_tls_block(tls_state_t *tls)
	{
	struct record_hdr *xhdr;
@@ -668,7 +703,7 @@ static int xread_tls_block(tls_state_t *tls)
	sz = target - sizeof(*xhdr);

	/* Needs to be decrypted? */
-	if (tls->min_encrypted_len_on_read) {
+	if (tls->min_encrypted_len_on_read > SHA256_OUTSIZE) {
	psCipherContext_t ctx;
	uint8_t p = tls->inbuf + sizeof(xhdr);
	int padding_len;
@@ -698,6 +733,10 @@ static int xread_tls_block(tls_state_t *tls)
	/* Skip IV */
	memmove(tls->inbuf + 5, tls->inbuf + 5 + AES_BLOCKSIZE, sz);
	}
+	} else {
+	/* if nonzero, then it's TLS_RSA_WITH_NULL_SHA256: drop MAC */
+	/* else: no encryption yet on input, subtract zero = NOP */
+	sz -= tls->min_encrypted_len_on_read;
	}

	/* RFC 5246 is not saying it explicitly, but sha256 hash
@@ -943,39 +982,24 @@ static int xread_tls_handshake_block(tls_state_t *tls, int min_len)
	return len;
	}

-	static void fill_handshake_record_hdr(struct record_hdr *xhdr, unsigned len)
+	static ALWAYS_INLINE void fill_handshake_record_hdr(void *buf, unsigned type, unsigned len)
	{
	struct handshake_hdr {
-	struct record_hdr xhdr;
	uint8_t type;
	uint8_t len24_hi, len24_mid, len24_lo;
-	} h = (void)xhdr;
-
-	h->xhdr.type = RECORD_TYPE_HANDSHAKE;
-	h->xhdr.proto_maj = TLS_MAJ;
-	h->xhdr.proto_min = TLS_MIN;
-	len -= 5;
-	h->xhdr.len16_hi = len >> 8;
-	// can be optimized to do one store instead of four:
-	// uint32_t v = htonl(0x100(RECORD_TYPE_HANDSHAKE + 0x100(TLS_MAJ + 0x100*(TLS_MIN))))
-	// \| ((len >> 8) << 24); // little-endian specific, don't use in this form
-	// (uint32_t )xhdr = v;
-
-	h->xhdr.len16_lo = len & 0xff;
+	} *h = buf;

	len -= 4;
+	h->type = type;
	h->len24_hi = len >> 16;
	h->len24_mid = len >> 8;
	h->len24_lo = len & 0xff;
-
-	memset(h + 1, 0, len);
	}

	//TODO: implement RFC 5746 (Renegotiation Indication Extension) - some servers will refuse to work with us otherwise
	static void send_client_hello(tls_state_t *tls)
	{
	struct client_hello {
-	struct record_hdr xhdr;
	uint8_t type;
	uint8_t len24_hi, len24_mid, len24_lo;
	uint8_t proto_maj, proto_min;
@@ -987,25 +1011,25 @@ static void send_client_hello(tls_state_t *tls)
	uint8_t comprtypes_len;
	uint8_t comprtypes[1]; /* actually variable */
	};
-	struct client_hello record;
-
-	fill_handshake_record_hdr(&record.xhdr, sizeof(record));
-	record.type = HANDSHAKE_CLIENT_HELLO;
-	record.proto_maj = TLS_MAJ; /* the "requested" version of the protocol, */
-	record.proto_min = TLS_MIN; /* can be higher than one in record headers */
-	tls_get_random(record.rand32, sizeof(record.rand32));
-	/* record.session_id_len = 0; - already is */
-	/* record.cipherid_len16_hi = 0; */
-	record.cipherid_len16_lo = 2 * 1;
-	record.cipherid[0] = CIPHER_ID >> 8;
-	record.cipherid[1] = CIPHER_ID & 0xff;
-	record.comprtypes_len = 1;
-	/* record.comprtypes[0] = 0; */
+	struct client_hello record = tls_get_outbuf(tls, sizeof(record));
+
+	fill_handshake_record_hdr(record, HANDSHAKE_CLIENT_HELLO, sizeof(*record));
+	record->proto_maj = TLS_MAJ; /* the "requested" version of the protocol, */
+	record->proto_min = TLS_MIN; /* can be higher than one in record headers */
+	tls_get_random(record->rand32, sizeof(record->rand32));
+	memset(record->rand32, 0x11, sizeof(record->rand32));
+	memcpy(tls->client_and_server_rand32, record->rand32, sizeof(record->rand32));
+	record->session_id_len = 0;
+	record->cipherid_len16_hi = 0;
+	record->cipherid_len16_lo = 2 * 1;
+	record->cipherid[0] = CIPHER_ID >> 8;
+	record->cipherid[1] = CIPHER_ID & 0xff;
+	record->comprtypes_len = 1;
+	record->comprtypes[0] = 0;

	//dbg (make it repeatable): memset(record.rand32, 0x11, sizeof(record.rand32));
	dbg(">> CLIENT_HELLO\n");
-	xwrite_and_hash(tls, &record, sizeof(record));
-	memcpy(tls->client_and_server_rand32, record.rand32, sizeof(record.rand32));
+	xwrite_and_update_handshake_hash(tls, sizeof(*record));
	}

	static void get_server_hello(tls_state_t *tls)
@@ -1099,21 +1123,19 @@ static void get_server_cert(tls_state_t *tls)
	static void send_client_key_exchange(tls_state_t *tls)
	{
	struct client_key_exchange {
-	struct record_hdr xhdr;
	uint8_t type;
	uint8_t len24_hi, len24_mid, len24_lo;
	/* keylen16 exists for RSA (in TLS, not in SSL), but not for some other key types */
	uint8_t keylen16_hi, keylen16_lo;
	uint8_t key[4 * 1024]; // size??
	};
-	struct client_key_exchange record;
+	//FIXME: better size estimate
+	struct client_key_exchange record = tls_get_outbuf(tls, sizeof(record));
	uint8_t rsa_premaster[SSL_HS_RSA_PREMASTER_SIZE];
	int len;

-	fill_handshake_record_hdr(&record.xhdr, sizeof(record) - sizeof(record.key));
-	record.type = HANDSHAKE_CLIENT_KEY_EXCHANGE;
-
	tls_get_random(rsa_premaster, sizeof(rsa_premaster));
+	memset(rsa_premaster, 0x44, sizeof(rsa_premaster));
	// RFC 5246
	// "Note: The version number in the PreMasterSecret is the version
	// offered by the client in the ClientHello.client_version, not the
@@ -1123,22 +1145,20 @@ static void send_client_key_exchange(tls_state_t *tls)
	len = psRsaEncryptPub(/pool:/ NULL,
	/* psRsaKey_t* */ &tls->server_rsa_pub_key,
	rsa_premaster, /inlen:/ sizeof(rsa_premaster),
-	record.key, sizeof(record.key),
+	record->key, sizeof(record->key),
	data_param_ignored
	);
-	/* length fields need fixing */
-	record.keylen16_hi = len >> 8;
-	record.keylen16_lo = len & 0xff;
+	record->keylen16_hi = len >> 8;
+	record->keylen16_lo = len & 0xff;
	len += 2;
-	/* record.len24_hi = 0; - already is */
-	record.len24_mid = len >> 8;
-	record.len24_lo = len & 0xff;
+	record->type = HANDSHAKE_CLIENT_KEY_EXCHANGE;
+	record->len24_hi = 0;
+	record->len24_mid = len >> 8;
+	record->len24_lo = len & 0xff;
	len += 4;
-	record.xhdr.len16_hi = len >> 8;
-	record.xhdr.len16_lo = len & 0xff;

	dbg(">> CLIENT_KEY_EXCHANGE\n");
-	xwrite_and_hash(tls, &record, sizeof(record.xhdr) + len);
+	xwrite_and_update_handshake_hash(tls, len);

	// RFC 5246
	// For all key exchange methods, the same algorithm is used to convert
@@ -1224,7 +1244,6 @@ static const uint8_t rec_CHANGE_CIPHER_SPEC[] = {

	static void send_change_cipher_spec(tls_state_t *tls)
	{
-	/* Not "xwrite_and_hash": this is not a handshake message */
	dbg(">> CHANGE_CIPHER_SPEC\n");
	xwrite(tls->fd, rec_CHANGE_CIPHER_SPEC, sizeof(rec_CHANGE_CIPHER_SPEC));
	}
@@ -1269,19 +1288,17 @@ static void send_change_cipher_spec(tls_state_t *tls)
	static void send_client_finished(tls_state_t *tls)
	{
	struct finished {
-	struct record_hdr xhdr;
	uint8_t type;
	uint8_t len24_hi, len24_mid, len24_lo;
	uint8_t prf_result[12];
	};
-	struct finished record;
+	struct finished record = tls_get_outbuf(tls, sizeof(record));
	uint8_t handshake_hash[SHA256_OUTSIZE];

-	fill_handshake_record_hdr(&record.xhdr, sizeof(record));
-	record.type = HANDSHAKE_FINISHED;
+	fill_handshake_record_hdr(record, HANDSHAKE_FINISHED, sizeof(*record));

	sha256_peek(&tls->handshake_sha256_ctx, handshake_hash);
-	prf_hmac_sha256(record.prf_result, sizeof(record.prf_result),
+	prf_hmac_sha256(record->prf_result, sizeof(record->prf_result),
	tls->master_secret, sizeof(tls->master_secret),
	"client finished",
	handshake_hash, sizeof(handshake_hash)
@@ -1289,13 +1306,10 @@ static void send_client_finished(tls_state_t *tls)
	dump_hex("from secret: %s\n", tls->master_secret, sizeof(tls->master_secret));
	dump_hex("from labelSeed: %s", "client finished", sizeof("client finished")-1);
	dump_hex("%s\n", handshake_hash, sizeof(handshake_hash));
-	dump_hex("=> digest: %s\n", record.prf_result, sizeof(record.prf_result));
-
-	//(1) TODO: well, this should be encrypted on send, really.
-	//(2) do we really need to also hash it?
+	dump_hex("=> digest: %s\n", record->prf_result, sizeof(record->prf_result));

	dbg(">> FINISHED\n");
-	xwrite_and_hash(tls, &record, sizeof(record));
+	xwrite_encrypted(tls, sizeof(*record), RECORD_TYPE_HANDSHAKE);
	}

	static void tls_handshake(tls_state_t *tls)
@@ -1376,8 +1390,11 @@ static void tls_handshake(tls_state_t *tls)
	if (len != 1 \|\| memcmp(tls->inbuf, rec_CHANGE_CIPHER_SPEC, 6) != 0)
	tls_error_die(tls);
	dbg("<< CHANGE_CIPHER_SPEC\n");
-	/* all incoming packets now should be encrypted and have IV + MAC + padding */
-	tls->min_encrypted_len_on_read = AES_BLOCKSIZE + SHA256_OUTSIZE + AES_BLOCKSIZE;
+	if (CIPHER_ID == TLS_RSA_WITH_NULL_SHA256)
+	tls->min_encrypted_len_on_read = SHA256_OUTSIZE;
+	else
+	/* all incoming packets now should be encrypted and have IV + MAC + padding */
+	tls->min_encrypted_len_on_read = AES_BLOCKSIZE + SHA256_OUTSIZE + AES_BLOCKSIZE;

	/* Get (encrypted) FINISHED from the server */
	len = xread_tls_block(tls);
@@ -1387,6 +1404,12 @@ static void tls_handshake(tls_state_t *tls)
	/* application data can be sent/received */
	}

+	static void tls_xwrite(tls_state_t *tls, int len)
+	{
+	dbg(">> DATA\n");
+	xwrite_encrypted(tls, len, RECORD_TYPE_APPLICATION_DATA);
+	}
+
	// To run a test server using openssl:
	// openssl req -x509 -newkey rsa:$((4096/4*3)) -keyout key.pem -out server.pem -nodes -days 99999 -subj '/CN=localhost'
	// openssl s_server -key key.pem -cert server.pem -debug -tls1_2 -no_tls1 -no_tls1_1
@@ -1400,8 +1423,8 @@ int tls_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
	int tls_main(int argc UNUSED_PARAM, char **argv)
	{
	tls_state_t *tls;
-	len_and_sockaddr *lsa;
-	int fd;
+	fd_set readfds, testfds;
+	int cfd;

	// INIT_G();
	// getopt32(argv, "myopts")
@@ -1409,13 +1432,48 @@ int tls_main(int argc UNUSED_PARAM, char **argv)
	if (!argv[1])
	bb_show_usage();

-	lsa = xhost2sockaddr(argv[1], 443);
-	fd = xconnect_stream(lsa);
+	cfd = create_and_connect_stream_or_die(argv[1], 443);

	tls = new_tls_state();
-	tls->fd = fd;
+	tls->fd = cfd;
	tls_handshake(tls);

+	/* Select loop copying stdin to cfd, and cfd to stdout */
+	FD_ZERO(&readfds);
+	FD_SET(cfd, &readfds);
+	FD_SET(STDIN_FILENO, &readfds);
+
+	#define iobuf bb_common_bufsiz1
+	setup_common_bufsiz();
+	for (;;) {
+	int nread;
+
+	testfds = readfds;
+
+	if (select(cfd + 1, &testfds, NULL, NULL, NULL) < 0)
+	bb_perror_msg_and_die("select");
+
+	if (FD_ISSET(STDIN_FILENO, &testfds)) {
+	void *buf = tls_get_outbuf(tls, COMMON_BUFSIZE);
+	nread = safe_read(STDIN_FILENO, buf, COMMON_BUFSIZE);
+	if (nread < 1) {
+	//&& errno != EAGAIN
+	/* Close outgoing half-connection so they get EOF,
+	* but leave incoming alone so we can see response */
+	// shutdown(cfd, SHUT_WR);
+	FD_CLR(STDIN_FILENO, &readfds);
+	}
+	tls_xwrite(tls, nread);
+	}
+	if (FD_ISSET(cfd, &testfds)) {
+	nread = xread_tls_block(tls);
+	if (nread < 1)
+	//if eof, just close stdout, but not exit!
+	return EXIT_SUCCESS;
+	xwrite(STDOUT_FILENO, tls->inbuf + 5, nread);
+	}
+	}
+
	return EXIT_SUCCESS;
	}
	/* Unencryped SHA256 example: