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

charm/adapters/pkenc_adapt_chk04.py

@@ -0,0 +1,91 @@
+'''
+**Canetti-Halevi-Katz IBE-to-PKE Transform (CHK04)**
+
+*Description:* Transforms an Identity-Based Encryption scheme into a CCA-secure
+Public Key Encryption scheme using generic composition of IBE + one-time signature.
+
+| **Based on:** Chosen-Ciphertext Security from Identity-Based Encryption
+| **Published in:** CRYPTO 2004
+| **Available from:** https://eprint.iacr.org/2003/182
+| **Notes:** Requires a selective-ID secure IBE scheme and an EU-CMA one-time signature scheme
+
+.. rubric:: Adapter Properties
+
+* **Type:** IBE-to-PKE transform
+* **Underlying Scheme:** selective-ID secure IBE + EU-CMA one-time signature
+* **Purpose:** constructs CCA-secure public key encryption from IBE and signatures
+
+.. rubric:: Implementation
+
+:Authors: J. Ayo Akinyele
+:Date: 1/2011
+'''
+from charm.toolbox.PKEnc import *
+from charm.toolbox.IBSig import *
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+
+debug = False
+class CHK04(PKEnc):
+    """
+    >>> from charm.adapters.ibenc_adapt_identityhash import HashIDAdapter
+    >>> from charm.schemes.ibenc.ibenc_bb03 import IBE_BB04
+    >>> from charm.schemes.pksig.pksig_bls04 import BLS01
+    >>> group = PairingGroup('SS512')
+    >>> ibe = IBE_BB04(group)
+    >>> hash_ibe = HashIDAdapter(ibe, group)
+    >>> ots = BLS01(group)
+    >>> pkenc = CHK04(hash_ibe, ots, group)
+    >>> (public_key, secret_key) = pkenc.keygen(0)
+    >>> msg = group.random(GT)
+    >>> cipher_text = pkenc.encrypt(public_key, msg)
+    >>> decrypted_msg = pkenc.decrypt(public_key, secret_key, cipher_text)
+    >>> decrypted_msg == msg
+    True
+    """
+    def __init__(self, ibe_scheme, ots_scheme, groupObj):
+        PKEnc.__init__(self)
+        global ibe, ots, group
+        criteria1 = [('secDef', 'IND_ID_CPA'), ('scheme', 'IBEnc'), ('id', str)]
+        criteria2 = [('secDef', 'EU_CMA'), ('scheme', 'IBSig')] 
+        if PKEnc.checkProperty(self, ibe_scheme, criteria1): # and PKEnc.checkProperty(self, ots_scheme, criteria2):
+            PKEnc.updateProperty(self, ibe_scheme, secDef=IND_CCA, secModel=SM)
+            ibe = ibe_scheme
+            ots = ots_scheme
+            #PKEnc.printProperties(self)
+        else:
+            assert False, "Input scheme does not satisfy adapter properties: %s" % criteria
+
+        group = groupObj
+		
+    def keygen(self, secparam):
+        # Run the IBE Setup routine to generate (mpk, msk)
+        (mpk, msk) = ibe.setup()
+        
+        pk = { 'mpk' : mpk, 'secparam':secparam }
+        return (pk, msk)
+
+    def encrypt(self, pk, message):
+        # Generate a random keypair for the OTS
+        (svk, ssk) = ots.keygen(pk['secparam'])		
+
+        # print("pub identity enc =>", _id)
+
+        # Encrypt message with the IBE scheme under 'identity' vk
+        C = ibe.encrypt(pk['mpk'],svk['identity'] , message)
+        # Sign the resulting ciphertext with sk
+        sigma = ots.sign(ssk['x'], C)
+        return { 'vk' : svk, 'C' : C, 'sigma' : sigma }
+		
+    # NOTE: need to transform c['vk'] into a string to use as key        
+    def decrypt(self, pk, sk, c):
+        # Given a ciphertext (vk, C, sigma), verify that sigma is a signature on C under public key vk
+        if not ots.verify(c['vk'], c['sigma'], c['C']):
+            return False
+
+        identity = c['vk']['identity']
+        # print("identity in dec =>", identity)
+        # Otherwise, extract an IBE key for identity 'vk' under the master secret params
+        dk = ibe.extract(sk, identity)
+        # Return the decryption of the ciphertext element "C" under key dk
+        return ibe.decrypt(pk, dk, c['C'])
+

charm/adapters/pkenc_adapt_hybrid.py

@@ -0,0 +1,98 @@
+'''
+**Hybrid Encryption Adapter for PKE (PKE Hybrid)**
+
+*Description:* Converts a Public Key Encryption scheme into a hybrid encryption
+scheme capable of encrypting arbitrary-length messages.
+
+| **Notes:** Uses symmetric encryption (AES) with a randomly generated session key.
+| The session key is encrypted using the underlying PKE scheme.
+| Works with ElGamal and CS98 schemes.
+
+.. rubric:: Adapter Properties
+
+* **Type:** hybrid encryption adapter
+* **Underlying Scheme:** any public key encryption scheme (e.g., ElGamal, CS98)
+* **Purpose:** enables PKE schemes to encrypt arbitrary-length byte messages
+
+.. rubric:: Implementation
+
+:Authors: J. Ayo Akinyele
+:Date: 2011
+'''
+
+# Works for ElGamal and CS98 schemes
+from charm.toolbox.PKEnc import PKEnc
+from charm.toolbox.securerandom import OpenSSLRand
+from charm.toolbox.symcrypto import AuthenticatedCryptoAbstraction
+from charm.toolbox.ecgroup import ECGroup
+from charm.toolbox.eccurve import prime192v1
+from charm.schemes.pkenc.pkenc_cs98 import CS98
+from charm.core.crypto.cryptobase import AES
+debug = False
+
+# Adapter class for Hybrid Encryption Schemes
+class HybridEnc(PKEnc):
+    """
+    >>> groupObj = ECGroup(prime192v1)
+    >>> pkenc = CS98(groupObj)
+    >>> hyenc = HybridEnc(pkenc, msg_len=groupObj.bitsize())
+    >>> (public_key, secret_key) = hyenc.keygen()
+    >>> msg = b'this is a new message'
+    >>> cipher_text = hyenc.encrypt(public_key, msg)
+    >>> decrypted_msg = hyenc.decrypt(public_key, secret_key, cipher_text)
+    >>> decrypted_msg == msg
+    True
+    """
+    def __init__(self, pkenc, msg_len=16, key_len=16, mode=AES):
+        PKEnc.__init__(self)
+        # check that pkenc satisfies properties of a pkenc scheme
+        if hasattr(pkenc, 'keygen') and hasattr(pkenc, 'encrypt') and hasattr(pkenc, 'decrypt'):
+            self.pkenc = pkenc
+            self.key_len = key_len # 128-bit session key by default
+            self.msg_len = msg_len
+            self.alg = mode
+            if debug: print("PKEnc satisfied.")
+    
+    def keygen(self, secparam=None):
+        if secparam == None:
+           # ec module group
+           return self.pkenc.keygen()
+        # integer group
+        return self.pkenc.keygen(secparam)
+    
+    def encrypt(self, pk, M):
+        # generate a short session key, K and encrypt using pkenc
+        key = OpenSSLRand().getRandomBytes(self.msg_len)
+        # encrypt session key using PKEnc
+        c1 = self.pkenc.encrypt(pk, key)
+        # use symmetric key encryption to enc actual message
+        c2 = AuthenticatedCryptoAbstraction(key).encrypt(M)
+        if debug: print("Ciphertext...")
+        if debug: print(c2)
+        return { 'c1':c1, 'c2':c2 }
+    
+    def decrypt(self, pk, sk, ct):
+        c1, c2 = ct['c1'], ct['c2']
+        key = self.pkenc.decrypt(pk, sk, c1)[:self.key_len]
+        if debug: print("Rec key =>", key, ", len =", len(key))
+        msg = AuthenticatedCryptoAbstraction(key).decrypt(c2)
+        if debug: print("Rec msg =>", msg)
+        return msg
+    
+def main():
+    groupObj = ECGroup(prime192v1)
+    pkenc = CS98(groupObj)
+    hyenc = HybridEnc(pkenc)
+       
+    (pk, sk) = hyenc.keygen()
+       
+    m = b'this is a new message'
+
+    cipher = hyenc.encrypt(pk, m)
+    orig_m = hyenc.decrypt(pk, sk, cipher)
+    assert m == orig_m, "Failed Decryption"
+    if debug: print("Successful Decryption!!")
+
+if __name__ == "__main__":
+   debug = True
+   main()

charm/adapters/pksig_adapt_naor01.py

@@ -0,0 +1,89 @@
+'''
+**Naor's IBE-to-Signature Transform (Naor01)**
+
+*Description:* Transforms a fully-secure Identity-Based Encryption scheme into a
+digital signature scheme using Naor's construction.
+
+| **Based on:** Identity-Based Encryption from the Weil Pairing
+| **Published in:** CRYPTO 2001
+| **Available from:** https://eprint.iacr.org/2001/090.pdf
+| **Notes:** First described by Boneh and Franklin, credited to Moni Naor.
+| Uses IBE key extraction as signing; verification via encrypt-then-decrypt.
+| **Warning:** Not secure for selectively-secure IBE schemes!
+
+.. rubric:: Adapter Properties
+
+* **Type:** IBE-to-signature transform
+* **Underlying Scheme:** any fully-secure IBE scheme
+* **Purpose:** constructs digital signatures from Identity-Based Encryption
+
+.. rubric:: Implementation
+
+:Authors: J. Ayo Akinyele
+:Date: 05/2011
+'''
+
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+from charm.toolbox.IBEnc import *
+from charm.toolbox.PKSig import *
+
+debug = False
+class Sig_Generic_ibetosig_Naor01(PKSig):
+    """
+    >>> from charm.toolbox.pairinggroup import PairingGroup,ZR
+    >>> from charm.schemes.ibenc.ibenc_bb03 import IBE_BB04
+    >>> from charm.adapters.ibenc_adapt_identityhash import HashIDAdapter
+    >>> group = PairingGroup('MNT224')
+    >>> ibe = IBE_BB04(group)
+    >>> hashID = HashIDAdapter(ibe, group)    
+    >>> ibsig = Sig_Generic_ibetosig_Naor01(hashID, group)
+    >>> (master_public_key, master_secret_key) = ibsig.keygen()
+    >>> msg = b"hello world!!!"
+    >>> signature = ibsig.sign(master_secret_key, msg)
+    >>> ibsig.verify(master_public_key, msg, signature) 
+    True
+    """
+    def __init__(self, ibe_scheme, groupObj):
+        PKSig.__init__(self)
+        global ibe, group
+        # validate that we have the appropriate object
+        criteria = [('secDef', IND_ID_CPA), ('scheme', 'IBEnc'), ('messageSpace', GT)]
+        if PKSig.checkProperty(self, ibe_scheme, criteria):
+            # change our property as well
+            PKSig.updateProperty(self, ibe_scheme, secDef=EU_CMA, id=str, secModel=ROM)
+            ibe = ibe_scheme
+            #PKSig.printProperties(self)
+        else:
+            assert False, "Input scheme does not satisfy adapter properties: %s" % criteria        
+        group = groupObj
+				
+    def keygen(self):
+        (mpk, msk) = ibe.setup()
+        if debug: print("Keygen...")
+        group.debug(mpk)
+        group.debug(msk)
+        return (mpk, msk)
+
+    def sign(self, sk, m):
+        assert type(m) in [str, bytes], "invalid message type!"
+        return ibe.extract(sk, m)
+		
+    def verify(self, pk, m, sig):
+        # Some IBE scheme support a native method for validating IBE keys.  Use this if it exists.
+        if hasattr(ibe, 'verify'):
+            result = ibe.verify(pk, m, sig)
+            if result == False: return False
+		
+        assert m == sig['IDstr'], "message not thesame as ID in signature"
+        # Encrypt a random message in the IBE's message space and try to decrypt it
+        new_m = group.random(GT)
+        if debug: print("\nRandom message =>", new_m)
+
+        C = ibe.encrypt(pk, sig['IDstr'], new_m)
+         
+        if (ibe.decrypt(pk, sig, C) == new_m):
+            return True
+        else:
+            return False
+
+

charm/config.py

@@ -0,0 +1,7 @@
+from charm.toolbox.enum import Enum
+
+libs = Enum('openssl', 'gmp', 'pbc', 'miracl', 'relic')
+
+pairing_lib=libs.pbc
+ec_lib=libs.openssl
+int_lib=libs.gmp

charm/core/benchmark/benchmark_util.c

@@ -0,0 +1,353 @@
+
+#if defined(__APPLE__)
+// benchmark new
+PyObject *Benchmark_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+  Benchmark *self;
+  self = (Benchmark *)type->tp_alloc(type, 0);
+  if(self != NULL) {
+    self->bench_initialized = FALSE;
+    self->bench_inprogress = FALSE;  // false until we StartBenchmark( ... )
+    self->op_add = self->op_sub = self->op_mult = 0;
+    self->op_div = self->op_exp = self->op_pair = 0;
+    self->cpu_time_ms = self->real_time_ms = 0.0;
+    self->cpu_option = self->real_option = FALSE;
+    debug("Creating new benchmark object.\n");
+  }
+  return (PyObject *) self;
+}
+
+// benchmark init
+int Benchmark_init(Benchmark *self, PyObject *args, PyObject *kwds)
+{
+  return 0;
+}
+// benchmark dealloc
+void Benchmark_dealloc(Benchmark *self) {
+  debug("Releasing benchmark object.\n");
+  Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+PyTypeObject BenchmarkType = {
+  PyVarObject_HEAD_INIT(NULL, 0)
+  "profile.Benchmark",       /*tp_name*/
+  sizeof(Benchmark),         /*tp_basicsize*/
+  0,                         /*tp_itemsize*/
+  (destructor)Benchmark_dealloc, /*tp_dealloc*/
+  0,                         /*tp_print*/
+  0,                         /*tp_getattr*/
+  0,                         /*tp_setattr*/
+  0,                /*tp_reserved*/
+  0, /*tp_repr*/
+  0,               /*tp_as_number*/
+  0,                         /*tp_as_sequence*/
+  0,                         /*tp_as_mapping*/
+  0,   /*tp_hash */
+  0,                         /*tp_call*/
+  0, /*tp_str*/
+  0,                         /*tp_getattro*/
+  0,                         /*tp_setattro*/
+  0,                         /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "Benchmark objects",           /* tp_doc */
+  0,                   /* tp_traverse */
+  0,                   /* tp_clear */
+  0,          /* tp_richcompare */
+  0,                   /* tp_weaklistoffset */
+  0,                   /* tp_iter */
+  0,                   /* tp_iternext */
+  0,             /* tp_methods */
+  0,             /* tp_members */
+  0,                         /* tp_getset */
+  0,                         /* tp_base */
+  0,                         /* tp_dict */
+  0,                         /* tp_descr_get */
+  0,                         /* tp_descr_set */
+  0,                         /* tp_dictoffset */
+  (initproc)Benchmark_init,      /* tp_init */
+  0,                         /* tp_alloc */
+  Benchmark_new,                 /* tp_new */
+};
+
+#endif
+
+void Operations_dealloc(Operations *self)
+{
+	debug("Releasing operations object.\n");
+	Py_TYPE(self)->tp_free((PyObject *) self);
+}
+
+PyObject *Operations_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+	Operations *self = (Operations *) type->tp_alloc(type, 0);
+	if(self != NULL) {
+		/* initialize */
+		self->op_init = FALSE;
+	}
+
+	return (PyObject *) self;
+}
+
+int Operations_init(Operations *self, PyObject *args, PyObject *kwds)
+{
+	self->op_init = TRUE;
+	return 0;
+}
+
+/* for python 3.x */
+PyTypeObject OperationsType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"profile.Operations",             /*tp_name*/
+	sizeof(Operations),         /*tp_basicsize*/
+	0,                         /*tp_itemsize*/
+	(destructor)Operations_dealloc, /*tp_dealloc*/
+	0,                         /*tp_print*/
+	0,                         /*tp_getattr*/
+	0,                         /*tp_setattr*/
+	0,			   				/*tp_reserved*/
+	0, 							/*tp_repr*/
+	0,               		   /*tp_as_number*/
+	0,                         /*tp_as_sequence*/
+	0,                         /*tp_as_mapping*/
+	0,                         /*tp_hash */
+	0,                         /*tp_call*/
+	0,                         /*tp_str*/
+	0,                         /*tp_getattro*/
+	0,                         /*tp_setattro*/
+	0,                         /*tp_as_buffer*/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+	"Granular benchmark objects",           /* tp_doc */
+	0,		               /* tp_traverse */
+	0,		               /* tp_clear */
+	0,		       		   /* tp_richcompare */
+	0,		               /* tp_weaklistoffset */
+	0,		               /* tp_iter */
+	0,		               /* tp_iternext */
+	0, 			            /* tp_methods */
+	0,             			   /* tp_members */
+	0,                         /* tp_getset */
+	0,                         /* tp_base */
+	0,                         /* tp_dict */
+	0,                         /* tp_descr_get */
+	0,                         /* tp_descr_set */
+	0,                         /* tp_dictoffset */
+	(initproc)Operations_init,      /* tp_init */
+	0,                         /* tp_alloc */
+	Operations_new,                 /* tp_new */
+};
+
+PyObject *InitBenchmark(PyObject *self, PyObject *args) {
+	Benchmark *benchObj = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "InitBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		benchObj = PyObject_New(Benchmark, &BenchmarkType);
+		if (benchObj == NULL) {
+			PyErr_SetString(BENCH_ERROR, "out of memory.");
+			return NULL;
+		}
+
+		/* setup granular options */
+		if(group->gBench == NULL) {
+			group->gBench = PyObject_New(Operations, &OperationsType);
+			CLEAR_ALLDBENCH(group->gBench);
+		}
+		benchObj->num_options = 0;
+		benchObj->op_add = benchObj->op_sub = benchObj->op_mult = 0;
+		benchObj->op_div = benchObj->op_exp = benchObj->op_pair = 0;
+		benchObj->cpu_time_ms = 0.0;
+		benchObj->real_time_ms = 0.0;
+		benchObj->bench_initialized = TRUE;
+		benchObj->bench_inprogress = FALSE;
+		benchObj->identifier = BenchmarkIdentifier;
+		debug("%s: bench id set: '%i'\n", __FUNCTION__, benchObj->identifier);
+		debug("Initialized benchmark object.\n");
+		// set benchmark field in group object
+		group->dBench = benchObj;
+		RAND_pseudo_bytes(group->bench_id, ID_LEN);
+		Py_RETURN_TRUE;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && group->dBench->bench_initialized == TRUE) {
+		// if we have initialized the benchmark object and ended a benchmark execution:
+		// action: reset the fields
+		debug("Reset benchmark state.\n");
+		if(group->gBench != NULL) {
+			CLEAR_ALLDBENCH(group->gBench);
+		}
+		PyClearBenchmark(group->dBench);
+		group->dBench->bench_initialized = TRUE;
+		group->dBench->bench_inprogress = FALSE;
+		group->dBench->identifier = BenchmarkIdentifier;
+		Py_RETURN_TRUE;
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		debug("Benchmark in progress.\n");
+	}
+	debug("Benchmark already initialized.\n");
+	Py_RETURN_FALSE;
+}
+
+PyObject *StartBenchmark(PyObject *self, PyObject *args)
+{
+	PyObject *list = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "OO", &group, &list)) {
+		PyErr_SetString(BENCH_ERROR, "StartBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(PyList_Check(list) && group->dBench->bench_initialized == TRUE && group->dBench->bench_inprogress == FALSE
+			&& group->dBench->identifier == BenchmarkIdentifier)
+	{
+		debug("%s: bench id: '%i'\n", __FUNCTION__, group->dBench->identifier);
+		size_t size = PyList_Size(list);
+		PyStartBenchmark(group->dBench, list, size);
+		debug("list size => %zd\n", size);
+		debug("benchmark enabled and initialized!\n");
+		Py_RETURN_TRUE;
+	}
+	Py_RETURN_FALSE;
+}
+
+PyObject *EndBenchmark(PyObject *self, PyObject *args)
+{
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "EndBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_initialized == TRUE && group->dBench->bench_inprogress == TRUE && group->dBench->identifier == BenchmarkIdentifier) {
+		PyEndBenchmark(group->dBench);
+		debug("%s: bench id: '%i'\n", __FUNCTION__, group->dBench->identifier);
+		Py_RETURN_TRUE;
+	}
+	Py_RETURN_FALSE;
+}
+
+PyObject *GetAllBenchmarks(PyObject *self, PyObject *args)
+{
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "GetGeneralBenchmarks - invalid argument.");
+		return NULL;
+	}
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && group->dBench->identifier == BenchmarkIdentifier) {
+		debug("%s: bench id: '%i'\n", __FUNCTION__, group->dBench->identifier);
+		// return GetResultsWithPair(group->dBench);
+		return GET_RESULTS_FUNC(group->dBench);
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		printf("Benchmark in progress.\n");
+	}
+	else {
+		debug("Invalid benchmark identifier.\n");
+	}
+	Py_RETURN_FALSE;
+}
+
+PyObject *GetBenchmark(PyObject *self, PyObject *args) {
+	char *opt = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "Os", &group, &opt))
+	{
+		PyErr_SetString(BENCH_ERROR, "GetBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	VERIFY_GROUP(group);
+	if(group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && group->dBench->identifier == BenchmarkIdentifier) {
+		return Retrieve_result(group->dBench, opt);
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		printf("Benchmark in progress.\n");
+	}
+	Py_RETURN_FALSE;
+}
+
+static PyObject *GranularBenchmark(PyObject *self, PyObject *args)
+{
+	PyObject *dict = NULL;
+	GROUP_OBJECT *group = NULL;
+	if(!PyArg_ParseTuple(args, "O", &group)) {
+		PyErr_SetString(BENCH_ERROR, "GetGranularBenchmark - invalid argument.");
+		return NULL;
+	}
+
+	if(group->gBench == NULL || group->dBench == NULL) {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+		return NULL;
+	}
+	else if(group->dBench->bench_inprogress == FALSE && BenchmarkIdentifier == group->dBench->identifier) {
+		if(group->dBench->granular_option == FALSE) {
+			PyErr_SetString(BENCH_ERROR, "granular option was not set.");
+			return NULL;
+		}
+		dict = PyDict_New();
+		if(dict == NULL) return NULL;
+		if(group->dBench->op_mult > 0) {
+			PyObject *MulList = PyCreateList(group->gBench, MULTIPLICATION);
+			//PrintPyRef('MulList Before =>', MulList);
+			PyDict_SetItemString(dict, "Mul", MulList);
+			Py_DECREF(MulList);
+		}
+
+		if(group->dBench->op_div > 0) {
+			PyObject *DivList = PyCreateList(group->gBench, DIVISION);
+			PyDict_SetItemString(dict, "Div", DivList);
+			Py_DECREF(DivList);
+		}
+
+		if(group->dBench->op_add > 0) {
+			PyObject *AddList = PyCreateList(group->gBench, ADDITION);
+			PyDict_SetItemString(dict, "Add", AddList);
+			Py_DECREF(AddList);
+		}
+
+		if(group->dBench->op_sub > 0) {
+			PyObject *SubList = PyCreateList(group->gBench, SUBTRACTION);
+			PyDict_SetItemString(dict, "Sub", SubList);
+			Py_DECREF(SubList);
+		}
+
+		if(group->dBench->op_exp > 0) {
+			PyObject *ExpList = PyCreateList(group->gBench, EXPONENTIATION);
+			PyDict_SetItemString(dict, "Exp", ExpList);
+			Py_DECREF(ExpList);
+		}
+		//PrintPyRef('MulList After =>', MulList);
+	}
+	else if(group->dBench->bench_inprogress == TRUE) {
+		printf("Benchmark in progress.\n");
+	}
+	else {
+		PyErr_SetString(BENCH_ERROR, "uninitialized benchmark object.");
+	}
+
+	return dict;
+}
+