charm-crypto-framework 0.61.1__cp313-cp313-macosx_10_13_universal2.whl

charm/core/math/pairing/relic/relic_interface.h

@@ -0,0 +1,217 @@
+/*
+ * Charm-Crypto is a framework for rapidly prototyping cryptosystems.
+ *
+ * Charm-Crypto is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Charm-Crypto is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Charm-Crypto. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Please contact the charm-crypto dev team at support@charm-crypto.com
+ * for any questions.
+ */
+
+/*
+*   @file    relic_interface.h
+*
+*   @brief   charm interface over RELIC's pairing-based crypto module
+*
+*   @author  jakinye3@jhu.edu
+*
+************************************************************************/
+
+#ifndef RELIC_INTERFACE_H
+#define RELIC_INTERFACE_H
+
+#include <stdlib.h>
+#include <math.h>
+#include "relic.h"
+/* make sure error checking enabled in relic_conf.h, ALLOC should be dynamic */
+
+//#define DISABLE_CHECK  1
+#define TRUE	1
+#define FALSE	0
+#define DBASE	16
+#define MAX_BUF	1024
+#define SHA_LEN  	32
+#define SHA_FUNC	md_map_sh256
+typedef enum _status_t { ELEMENT_OK = 2,
+	   ELEMENT_INVALID_ARG,
+	   ELEMENT_INVALID_ARG_LEN,
+	   ELEMENT_INVALID_TYPES,
+	   ELEMENT_INVALID_RESULT,
+	   ELEMENT_PAIRING_INIT_FAILED,
+	   ELEMENT_UNINITIALIZED,
+	   ELEMENT_DIV_ZERO,
+	   ELEMENT_INITIALIZED_ALRDY,
+} status_t;
+
+enum Group {ZR, G1, G2, GT, NONE_G};
+typedef enum Group GroupType;
+
+//new macros to fix Relic renaming
+#define FP_BYTES RLC_FP_BYTES
+#define fp_write fp_write_str
+#define BN_BYTES (RLC_BN_DIGS * sizeof(dig_t))
+#define BN_NEG RLC_NEG
+#define BN_POS RLC_POS
+#define STS_OK RLC_OK
+#define G1_TABLE RLC_G1_TABLE
+#define G2_TABLE RLC_G2_TABLE
+#define CMP_GT RLC_GT
+#define CMP_EQ RLC_EQ
+//end new macros
+
+#define FP_STR FP_BYTES * 2 + 1
+#define G1_LEN (FP_BYTES * 2) + 2
+#define G2_LEN (FP_BYTES * 4) + 4
+#define GT_LEN (FP_BYTES * 12) + 12
+
+struct element {
+	int isInitialized;
+	bn_t order;
+	GroupType type;
+	bn_t bn;
+	g1_t g1;
+	g2_t g2;
+	gt_t gt;
+};
+
+struct object {
+	int isInitialized;
+	g1_t *t1;
+	g2_t *t2;
+};
+
+typedef struct element element_t[1];
+typedef struct element *element_ptr;
+typedef struct object element_pp_t[1];
+typedef bn_t integer_t;
+int bn_is_one(bn_t a);
+
+/* Initialize 'e' to be an element of the ring Z_r of pairing.
+ * r is the order of the groups G1, G2 and GT that are involved in the pairing.
+ */
+status_t pairing_init(void); // must be able to set curve parameters dynamically
+status_t pairing_clear(void);
+
+status_t element_init_Zr(element_t e, int init_value);
+/* Initialize 'e' to be an element of the group G1, G2 or GT of pairing. */
+status_t element_init_G1(element_t e);
+status_t element_init_G2(element_t e);
+status_t element_init_GT(element_t e);
+/* selects random element from a uniform distribution */
+status_t element_random(element_t e);
+/* print contents of ane element structure */
+status_t element_printf(const char *msg, element_t e);
+status_t element_to_str(char *data, int len, element_t e);
+/* free mem. associated with a */
+status_t element_clear(element_t e);
+
+status_t element_pp_init(element_pp_t e_pp, element_t e);
+status_t element_pp_pow(element_t o, element_pp_t e_pp, GroupType type, element_t e);
+status_t element_pp_pow_int(element_t o, element_pp_t e_pp, GroupType type, integer_t bn);
+status_t element_pp_clear(element_pp_t e_pp, GroupType type);
+
+/* arithmetic operators over elements */
+// c = a + b
+status_t element_add(element_t c, element_t a, element_t b);
+// c = a - b
+status_t element_sub(element_t c, element_t a, element_t b);
+// c = a * b
+status_t element_mul(element_t c, element_t a, element_t b);
+// c = a * Zr
+status_t element_mul_zr(element_t c, element_t a, element_t b);
+// c = a * int
+status_t element_mul_int(element_t c, element_t a, integer_t b);
+// c = a / b
+status_t element_div(element_t c, element_t a, element_t b);
+status_t element_div_int(element_t c, element_t a, integer_t b);
+status_t element_int_div(element_t c, integer_t a, element_t b);
+
+// c = -a
+status_t element_neg(element_t c, element_t a);
+// c = 1 / a
+status_t element_invert(element_t c, element_t a);
+// c = a ^ b ( where b is ZR)
+status_t element_pow_zr(element_t c, element_t a, element_t b);
+// c = a ^ b ( where b is int)
+status_t element_pow_int(element_t c, element_t a, integer_t b);
+// compare a & b returns 0 if a==b, -1 if a < b and 1 if a > b
+int element_cmp(element_t a, element_t b);
+// check if element is zero
+int element_is_member(element_t e);
+int get_order(integer_t x);
+
+status_t pairing_apply(element_t et, element_t e1, element_t e2);
+
+// adjustable key derivation function
+status_t element_to_key(element_t e, uint8_t *data, int data_len, uint8_t label);
+status_t hash_buffer_to_bytes(uint8_t *input, int input_len, uint8_t *output, int output_len, uint8_t label);
+
+/* copy method: e = a */
+status_t element_set(element_t e, element_t a);
+status_t element_set_int(element_t e, integer_t x);
+status_t element_to_int(integer_t x, element_t e);
+status_t element_set_si(element_t e, unsigned int x);
+// void element_init_same_as(element_t e, element_t e2)
+int element_length(element_t e);
+/* generate an element of a particular type from data */
+status_t element_from_hash(element_t e, unsigned char *data, int len);
+/* serialize to bytes */
+status_t element_to_bytes(unsigned char *data, int data_len, element_t e);
+/* de-serialize from bytes */
+status_t element_from_bytes(element_t e, unsigned char *data, int data_len);
+
+void print_as_hex(uint8_t *data, size_t len);
+status_t charm_g1_read_bin(g1_t g, uint8_t *data, int data_len);
+status_t charm_g1_write_bin(g1_t g, uint8_t *data, int data_len);
+status_t charm_g1_write_str(g1_t g, uint8_t *data, int data_len);
+
+status_t charm_g2_read_bin(g2_t g, uint8_t *data, int data_len);
+status_t charm_g2_write_bin(g2_t g, uint8_t *data, int data_len);
+status_t charm_g2_write_str(g2_t g, uint8_t *data, int data_len);
+
+status_t charm_gt_read_bin(gt_t g, uint8_t *data, int data_len);
+status_t charm_gt_write_bin(gt_t g, uint8_t *data, int data_len);
+status_t charm_gt_write_str(gt_t g, uint8_t *data, int data_len);
+
+#define bn_inits(b) \
+		bn_null(b);	\
+		bn_new(b);
+
+#define g1_inits(g) \
+		g1_null(g);	\
+		g1_new(g);
+
+#define g2_inits(g) \
+		g2_null(g);	\
+		g2_new(g);
+
+#define gt_inits(g) \
+		gt_null(g);	\
+		gt_new(g);
+
+#ifdef DISABLE_CHECK
+#define LEAVE_IF(a, m)	/* empty */
+#define EXIT_IF_NOT_SAME(a, b)  /* empty */
+#else
+#define EXIT_IF_NOT_SAME(a, b)		\
+	if(a->type != b->type)	{		\
+		return ELEMENT_INVALID_TYPES; }
+
+#define LEAVE_IF(a, m)	\
+		if(a) {			\
+		  fprintf(stderr, "%s", m);	\
+		  return ELEMENT_INVALID_ARG;	}
+
+#endif
+
+#endif

charm/core/math/pairing/relic/test_relic.c

@@ -0,0 +1,171 @@
+#include <stdio.h>
+#include <sys/time.h>
+#include "relic_interface.h"
+
+/* prime curves */
+#define DEBUG		1
+#define TRIALS		1
+#define HEX		16
+
+//void printf_as_hex(unsigned char *buf, size_t len)
+//{
+//    size_t i;
+//    for(i = 0; i < len; i += 4)
+//    	printf("%02X%02X%02X%02X ", buf[i], buf[i+1], buf[i+2], buf[i+3]);
+//    printf("\n");
+//}
+
+//double calc_usecs(bench_t *start, bench_t *stop) {
+//	double usec_per_second = 1000000; // 1 000 000
+//	double result = usec_per_second * (stop->tv_sec - start->tv_sec);
+//
+//	if(stop->tv_usec >= stop->tv_usec) {
+//		result += (stop->tv_usec - start->tv_usec);
+//	}
+//	else {
+//		result -= (start->tv_usec - stop->tv_usec);
+//	}
+//
+//	return result / usec_per_second;
+//}
+
+/*
+double calc_msecs(bench_t *start, bench_t *stop) {
+	double msec_per_second = 1000; // 1 000 000
+	double usec_per_second = 1000000; // 1 000 000
+	double result1 = start->tv_sec + (start->tv_usec / usec_per_second);
+	double result2 = stop->tv_sec + (stop->tv_usec / usec_per_second);
+	return (result2 - result1) * msec_per_second;
+}
+*/
+
+int main(int argc, char *argv[])
+{
+	status_t result;
+	result = pairing_init();
+
+	if(result == ELEMENT_OK)
+		printf("pairing init: SUCCESS.\n");
+	else
+		printf("pairing init: FAILED!\n");
+
+
+	element_ptr e0 = (element_ptr) malloc(sizeof(element_t));
+	element_t e; // , e1, e2, e3;
+
+	/* Start ZR init & operations */
+	element_init_Zr(e, 0);
+	element_init_Zr(e0, 1234567890);
+
+	element_random(e);
+
+	element_printf("e  -> ZR :=> ", e);
+	element_printf("e0 -> ZR :=> ", e0);
+
+	element_add(e, e, e0);
+	element_printf("Add ZR :=> ", e);
+	element_sub(e0, e, e0);
+	element_printf("Sub ZR :=> ", e);
+
+	element_clear(e);
+	element_clear(e0);
+
+	/* End of ZR operations */
+
+
+	element_t g1_0, g1_1, g1_2, g2_1, g2_2, g2_nil, gt_1, gt_2;
+	/* Start G1 init & operations */
+	element_init_G1(g1_0);
+	element_printf("Identity G1 :=> \n", g1_0);
+	element_init_G1(g1_1);
+	element_init_G1(g1_2);
+	element_init_G2(g2_1);
+	element_init_G2(g2_2);
+	element_init_G2(g2_nil);
+	element_init_GT(gt_1);
+	element_init_GT(gt_2);
+	element_init_Zr(e0, 0);
+
+//	element_random(g1_0);
+//	element_random(g1_1);
+//
+//	element_add(g1_2, g1_0, g1_1);
+//	element_printf("Add G1 :=> \n", g1_2);
+//
+//	element_sub(g1_2, g1_2, g1_0);
+//	element_printf("Sub G1 :=> \n", g1_2);
+//
+//
+	unsigned char *msg = "hello world!";
+	element_from_hash(e0, msg, strlen((char *) msg));
+	element_from_hash(g1_2, msg, strlen((char *) msg));
+	element_from_hash(g2_2, msg, strlen((char *) msg));
+
+	element_printf("Hash into e0 :=> \n", e0);
+	element_printf("Hash into g1 :=> \n", g1_2);
+	element_printf("Hash into g2 :=> \n", g2_2);
+
+	printf("cmp elements ok! :=> '%d'\n", element_cmp(g1_2, g1_2));
+	printf("cmp elements fail:=> '%d'\n", element_cmp(g1_1, g1_2));
+
+	int d_len = element_length(g1_1);
+	if(d_len > 0) {
+		printf("%s: g1 d_len :=> '%d'\n", __FUNCTION__, d_len);
+		uint8_t data[d_len + 1];
+		element_to_bytes(data, d_len, g1_1);
+
+		element_from_bytes(g1_2, data, d_len);
+		element_printf("rec g1 :=> \n", g1_2);
+		printf("cmp elements after deserialize :=> '%d'\n", element_cmp(g1_1, g1_2));
+	}
+
+	d_len = element_length(g2_2);
+	if(d_len > 0) {
+		element_printf("g2 write bin :=> \n", g2_2);
+		printf("%s: g2 d_len :=> '%d'\n", __FUNCTION__, d_len);
+		uint8_t data[d_len + 1];
+		element_to_bytes(data, d_len, g2_2);
+
+		element_from_bytes(g2_1, data, d_len);
+		element_printf("Rec g2 :=> \n", g2_1);
+		printf("cmp elements after deserialize :=> '%d'\n", element_cmp(g2_1, g2_2));
+
+	}
+
+	element_random(gt_1);
+	d_len = element_length(gt_1);
+	if(d_len > 0) {
+		element_printf("gt print :=> \n", gt_1);
+		printf("%s: g2 d_len :=> '%d'\n", __FUNCTION__, d_len);
+		uint8_t data[d_len + 1];
+		element_to_bytes(data, d_len, gt_1);
+
+		element_from_bytes(gt_2, data, d_len);
+
+		element_printf("Rec gt :=> \n", gt_2);
+		printf("cmp elements after deserialize :=> '%d'\n", element_cmp(gt_1, gt_2));
+
+	}
+
+	element_pairing(gt_1, g1_1, g2_1);
+	element_printf("Pairing result :=> \n", gt_1);
+
+	element_printf("g2 :=> \n", g2_nil);
+	element_pairing(gt_2, g1_1, g2_nil);
+	element_printf("Pairing result :=> \n", gt_2);
+
+	element_clear(e0);
+	element_clear(g1_0);
+	element_clear(g1_1);
+	element_clear(g1_2);
+	element_clear(g2_1);
+	element_clear(g2_2);
+	element_clear(g2_nil);
+	element_clear(gt_1);
+	element_clear(gt_2);
+	/* End of G1 operations */
+
+	pairing_clear();
+	return 0;
+}
+

charm/core/math/pairing.pyi

@@ -0,0 +1,69 @@
+"""Type stubs for charm.core.math.pairing C extension module."""
+
+from typing import overload
+
+# Module-level constants (group types)
+ZR: int
+G1: int
+G2: int
+GT: int
+
+class Pairing:
+    """Pairing group context for bilinear pairings."""
+
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, params: str) -> None: ...
+    @overload
+    def __init__(self, params: bytes) -> None: ...
+
+class Element:
+    """Element in a pairing-based group (ZR, G1, G2, or GT)."""
+
+    type: int
+    initialized: int
+    preproc: int
+
+    def __init__(self) -> None: ...
+    def initPP(self) -> None: ...
+    def set(self, value: int | Element) -> int: ...
+
+    # Arithmetic operations
+    def __add__(self, other: Element) -> Element: ...
+    def __radd__(self, other: Element) -> Element: ...
+    def __sub__(self, other: Element) -> Element: ...
+    def __rsub__(self, other: Element) -> Element: ...
+    def __mul__(self, other: Element) -> Element: ...
+    def __rmul__(self, other: Element) -> Element: ...
+    def __pow__(self, other: Element | int) -> Element: ...
+    def __rpow__(self, other: Element | int) -> Element: ...
+    def __neg__(self) -> Element: ...
+    def __invert__(self) -> Element: ...
+
+    # Comparison operations
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __lt__(self, other: Element) -> bool: ...
+    def __le__(self, other: Element) -> bool: ...
+    def __gt__(self, other: Element) -> bool: ...
+    def __ge__(self, other: Element) -> bool: ...
+
+    # Conversion and hashing
+    def __int__(self) -> int: ...
+    def __hash__(self) -> int: ...
+
+# Module-level functions
+@overload
+def init(group: Pairing, type: int) -> Element: ...
+@overload
+def init(group: Pairing, type: int, value: int) -> Element: ...
+
+def pair(g1: Element, g2: Element) -> Element: ...
+def hashPair(element: Element) -> bytes: ...
+def H(group: Pairing, data: bytes | str, type: int) -> Element: ...
+def random(group: Pairing, type: int) -> Element: ...
+def serialize(element: Element) -> bytes: ...
+def deserialize(group: Pairing, data: bytes, type: int) -> Element: ...
+def ismember(element: Element) -> bool: ...
+

charm/core/utilities/base64.c

@@ -0,0 +1,248 @@
+#include "base64.h"
+
+//
+//  NSData+Base64.m
+//  base64
+//
+//  Created by Matt Gallagher on 2009/06/03.
+//  Copyright 2009 Matt Gallagher. All rights reserved.
+//
+//  Permission is given to use this source code file, free of charge, in any
+//  project, commercial or otherwise, entirely at your risk, with the condition
+//  that any redistribution (in part or whole) of source code must retain
+//  this copyright and permission notice. Attribution in compiled projects is
+//  appreciated but not required.
+
+//
+// Mapping from 6 bit pattern to ASCII character.
+//
+static unsigned char base64EncodeLookup[65] =
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+//
+// Definition for "masked-out" areas of the base64DecodeLookup mapping
+//
+#define xx 65
+
+//
+// Mapping from ASCII character to 6 bit pattern.
+//
+static unsigned char base64DecodeLookup[256] =
+{
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 62, xx, xx, xx, 63, 
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, xx, xx, xx, xx, xx, xx, 
+    xx,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, xx, xx, xx, xx, xx, 
+    xx, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+    xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, 
+};
+
+//
+// Fundamental sizes of the binary and base64 encode/decode units in bytes
+//
+#define BINARY_UNIT_SIZE 3
+#define BASE64_UNIT_SIZE 4
+
+//
+// NewBase64Decode
+//
+// Decodes the base64 ASCII string in the inputBuffer to a newly malloced
+// output buffer.
+//
+//  inputBuffer - the source ASCII string for the decode
+//	length - the length of the string or -1 (to specify strlen should be used)
+//	outputLength - if not-NULL, on output will contain the decoded length
+//
+// returns the decoded buffer. Must be free'd by caller. Length is given by
+//	outputLength.
+//
+void *NewBase64Decode(
+					  const char *inputBuffer,
+					  size_t length,
+					  size_t *outputLength)
+{
+	if ((int) length == -1)
+	{
+		length = strlen(inputBuffer);
+	}
+	
+	size_t outputBufferSize =
+	((length+BASE64_UNIT_SIZE-1) / BASE64_UNIT_SIZE) * BINARY_UNIT_SIZE;
+	unsigned char *outputBuffer = (unsigned char *)malloc(outputBufferSize);
+	
+	size_t i = 0;
+	size_t j = 0;
+	while (i < length)
+	{
+		//
+		// Accumulate 4 valid characters (ignore everything else)
+		//
+		unsigned char accumulated[BASE64_UNIT_SIZE];
+		size_t accumulateIndex = 0;
+		while (i < length)
+		{
+			unsigned char decode = base64DecodeLookup[(unsigned char)inputBuffer[i++]];
+			if (decode != xx)
+			{
+				accumulated[accumulateIndex] = decode;
+				accumulateIndex++;
+				
+				if (accumulateIndex == BASE64_UNIT_SIZE)
+				{
+					break;
+				}
+			}
+		}
+		
+		//
+		// Store the 6 bits from each of the 4 characters as 3 bytes
+		//
+		outputBuffer[j] = (accumulated[0] << 2) | (accumulated[1] >> 4);
+		outputBuffer[j + 1] = (accumulated[1] << 4) | (accumulated[2] >> 2);
+		outputBuffer[j + 2] = (accumulated[2] << 6) | accumulated[3];
+		j += accumulateIndex - 1;
+	}
+	
+	if (outputLength)
+	{
+		*outputLength = j;
+	}
+	return outputBuffer;
+}
+
+//
+// NewBase64Decode
+//
+// Encodes the arbitrary data in the inputBuffer as base64 into a newly malloced
+// output buffer.
+//
+//  inputBuffer - the source data for the encode
+//	length - the length of the input in bytes
+//  separateLines - if zero, no CR/LF characters will be added. Otherwise
+//		a CR/LF pair will be added every 64 encoded chars.
+//	outputLength - if not-NULL, on output will contain the encoded length
+//		(not including terminating 0 char)
+//
+// returns the encoded buffer. Must be free'd by caller. Length is given by
+//	outputLength.
+//
+char *NewBase64Encode(
+					  const void *buffer,
+					  size_t length,
+					  int separateLines,
+					  size_t *outputLength)
+{
+	const unsigned char *inputBuffer = (const unsigned char *)buffer;
+	
+#define MAX_NUM_PADDING_CHARS 2
+#define OUTPUT_LINE_LENGTH 64
+#define INPUT_LINE_LENGTH ((OUTPUT_LINE_LENGTH / BASE64_UNIT_SIZE) * BINARY_UNIT_SIZE)
+#define CR_LF_SIZE 2
+	
+	//
+	// Byte accurate calculation of final buffer size
+	//
+	size_t outputBufferSize =
+	((length / BINARY_UNIT_SIZE)
+	 + ((length % BINARY_UNIT_SIZE) ? 1 : 0))
+	* BASE64_UNIT_SIZE;
+	if (separateLines)
+	{
+		outputBufferSize +=
+		(outputBufferSize / OUTPUT_LINE_LENGTH) * CR_LF_SIZE;
+	}
+	
+	//
+	// Include space for a terminating zero
+	//
+	outputBufferSize += 1;
+	
+	//
+	// Allocate the output buffer
+	//
+	char *outputBuffer = (char *)malloc(outputBufferSize);
+	if (!outputBuffer)
+	{
+		return NULL;
+	}
+	
+	size_t i = 0;
+	size_t j = 0;
+	const size_t lineLength = separateLines ? INPUT_LINE_LENGTH : length;
+	size_t lineEnd = lineLength;
+	
+	while (TRUE)
+	{
+		if (lineEnd > length)
+		{
+			lineEnd = length;
+		}
+		
+		for (; i + BINARY_UNIT_SIZE - 1 < lineEnd; i += BINARY_UNIT_SIZE)
+		{
+			//
+			// Inner loop: turn 48 bytes into 64 base64 characters
+			//
+			outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];
+			outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i] & 0x03) << 4)
+												   | ((inputBuffer[i + 1] & 0xF0) >> 4)];
+			outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i + 1] & 0x0F) << 2)
+												   | ((inputBuffer[i + 2] & 0xC0) >> 6)];
+			outputBuffer[j++] = base64EncodeLookup[inputBuffer[i + 2] & 0x3F];
+		}
+		
+		if (lineEnd == length)
+		{
+			break;
+		}
+		
+		//
+		// Add the newline
+		//
+		outputBuffer[j++] = '\r';
+		outputBuffer[j++] = '\n';
+		lineEnd += lineLength;
+	}
+	
+	if (i + 1 < length)
+	{
+		//
+		// Handle the single '=' case
+		//
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];
+		outputBuffer[j++] = base64EncodeLookup[((inputBuffer[i] & 0x03) << 4)
+											   | ((inputBuffer[i + 1] & 0xF0) >> 4)];
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i + 1] & 0x0F) << 2];
+		outputBuffer[j++] =	'=';
+	}
+	else if (i < length)
+	{
+		//
+		// Handle the double '=' case
+		//
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0xFC) >> 2];
+		outputBuffer[j++] = base64EncodeLookup[(inputBuffer[i] & 0x03) << 4];
+		outputBuffer[j++] = '=';
+		outputBuffer[j++] = '=';
+	}
+	outputBuffer[j] = 0;
+	
+	//
+	// Set the output length and return the buffer
+	//
+	if (outputLength)
+	{
+		*outputLength = j;
+	}
+	return outputBuffer;
+}