--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/rinteger.cpp Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,262 @@
+/*
+* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include <bigint.h>
+#include <e32std.h>
+#include <random.h>
+#include "../common/inlines.h"
+
+
+/**
+ * Copy constructor
+ *
+ * This function performs a shallow copy,
+ * i.e. the memory holding the integer is not copied.
+ */
+EXPORT_C RInteger::RInteger(const RInteger& aInteger)
+ {
+ *this = aInteger;
+ }
+
+/**
+ * Assignment operator
+ *
+ * This function performs a shallow copy,
+ * i.e. the memory holding the integer is not copied.
+ */
+EXPORT_C RInteger& RInteger::operator=(const RInteger& aInteger)
+ {
+ iSize = aInteger.iSize;
+ iPtr = aInteger.iPtr;
+ return *this;
+ }
+
+
+/**
+ * Creates a new integer representing 0.
+ *
+ * @return An RInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(void)
+ {
+ return NewL(TInteger::Zero());
+ }
+
+/**
+ * Creates a new integer object representing a specified value.
+ *
+ * @param aValue A descriptor containing the big-endian binary
+ * representation of the value.
+ * @return An RInteger object representing the value.
+ */
+EXPORT_C RInteger RInteger::NewL(const TDesC8& aValue)
+ {
+ RInteger self;
+ //Construct zero's memory beyond the size of aValue after construction
+ self.CreateNewL(BytesToWords(aValue.Size()));
+ self.Construct(aValue);
+ return self;
+ }
+
+/**
+ * Creates an exact copy of an \c aInteger object.
+ *
+ * @param aInteger The integer you wish to copy
+ * @return An RInteger object representing an exact copy of
+ * aInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(const TInteger& aInteger)
+ {
+ RInteger self;
+ //don't need to CleanNewL as we'll copy straight from aInteger
+ self.CreateNewL(aInteger.Size());
+ self.Construct(aInteger);
+ return self;
+ }
+
+/**
+ * Creates a random integer uniformly distributed over [0, 2^aBits].
+ *
+ * @param aBits The number of bits you wish to randomly select.
+ * @param aAttr Enum specifying whether specific bits in the random number should
+ * be set. See TRandomAttribute for more information.
+ * @return A random RInteger object in the range specified.
+ */
+EXPORT_C RInteger RInteger::NewRandomL(TUint aBits, TRandomAttribute aAttr)
+ {
+ RInteger self;
+ self.CleanNewL(BitsToWords(aBits));
+ CleanupStack::PushL(self);
+ self.RandomizeL(aBits, aAttr);
+ CleanupStack::Pop(&self);
+ return self;
+ }
+
+/**
+ * Creates a random integer uniformly distributed over [x | min <= x <= max].
+ *
+ * @param aMin The smallest possible value for the random integer (inclusive).
+ * @param aMax The largest possible value for the random integer (inclusive).
+ * @return A random RInteger object in the range specified.
+ */
+EXPORT_C RInteger RInteger::NewRandomL(const TInteger& aMin,
+ const TInteger& aMax)
+ {
+ RInteger self;
+ self.CleanNewL(aMax.Size());
+ CleanupStack::PushL(self);
+ self.RandomizeL(aMin, aMax);
+ CleanupStack::Pop(&self);
+ return self;
+ }
+
+/**
+ * Finds a random prime integer in the range of [2, 2^aBits].
+ *
+ * This is done by picking a random integer and using that as a starting point
+ * for a sequential search for a prime. To verify the primality of number,
+ * this algorithm uses a probablistic primality test. This means that it is
+ * possible, although extremely improbable, that the number returned is a pseudoprime.
+ *
+ * @param aBits The number of bits you wish to randomly select your prime from.
+ * @param aAttr Enum specifying whether specific bits in the random number should
+ * be set. See TRandomAttribute for more information.
+ * @return A random RInteger representing a probable prime (with very high
+ * probablity) in the range specified.
+ */
+EXPORT_C RInteger RInteger::NewPrimeL(TUint aBits, TRandomAttribute aAttr)
+ {
+ RInteger self;
+ self.CleanNewL(BitsToWords(aBits));
+ CleanupStack::PushL(self);
+ self.PrimeRandomizeL(aBits, aAttr);
+ CleanupStack::Pop(&self);
+ return self;
+ }
+
+/**
+ * Creates a new integer from the value represented by \c aInteger.
+ *
+ * @param aInteger A signed word sized integer.
+ * @return An RInteger representation of aInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(TInt aInteger)
+ {
+ RInteger self;
+ self.CreateNewL(2);
+ self.Construct(aInteger);
+ return self;
+ }
+
+/**
+ * Creates a new integer with a preallocated internal storage of \c aNumWords all
+ * initialised to zero.
+ *
+ * The resulting RInteger object is logically equivalent to RInteger::NewL(0).
+ * The only difference is that the internal storage requirements have been
+ * specified to be larger than the default. This is useful if you are about
+ * to perform an operation on this integer, that you know the resulting size
+ * requirements of, and wish to avoid a heap resize.
+ *
+ * @param aNumWords The number of words for to preallocated and zero fill.
+ * @return An RInteger object representing 0 with a preallocated
+ * zero-filled internal storage of aNumWords.
+ */
+EXPORT_C RInteger RInteger::NewEmptyL(TUint aNumWords)
+ {
+ RInteger self;
+ self.CleanNewL(aNumWords);
+ //There's no construct as there isn't anything to do
+ return self;
+ }
+
+/**
+ * Creates an RInteger object with no associated internal (heap) storage.
+ *
+ * All data members are initialised to zero. It is safe (although not strictly necessary)
+ * to push such an RInteger object onto the CleanupStack. This is useful, for example, if
+ * you want to pass an RInteger object by reference into a function and have it create
+ * the representation of the actual integer for you.
+ *
+ * Note that performing any operation on such an RInteger object other than the default
+ * assignment operator or copy constructor will panic your code.
+ *
+ * @return A stack based class that has no associated internal storage and thus
+ * does not represent any number.
+ */
+EXPORT_C RInteger::RInteger(void)
+ {
+ }
+
+/**
+ * An overloaded TCleanupItem() allowing the RIntegers to be pushed,
+ * popped, and destroyed via the CleanupStack like any other CBase derived object.
+ */
+EXPORT_C RInteger::operator TCleanupItem(void)
+ {
+ return TCleanupItem(&RInteger::CallClose, this);
+ }
+
+/**
+ * Helper function registered with the cleanup stack that just calls Close() for
+ * this RInteger object.
+ *
+ * @param aPtr A pointer to the object for which clean-up is to be performed.
+ */
+EXPORT_C void RInteger::CallClose(TAny* aPtr)
+ {
+ ((RInteger*)aPtr)->Close();
+ }
+
+/**
+ * Zeros and then frees any memory owned by this RInteger object.
+ *
+ * An RInteger object that has been closed can safely fall off the stack.
+ */
+EXPORT_C void RInteger::Close(void)
+ {
+ if (iPtr)
+ {
+ Mem::FillZ(Ptr(), Size()*4);
+ User::Free(Ptr());
+ iSize = 0;
+ iPtr = NULL;
+ }
+ }
+
+// Method is excluded from coverage due to the problem with BullsEye on ONB.
+// Manually verified that this method is functionally covered.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+/**
+ * Creates a new integer from the value represented by \c aInteger.
+ *
+ * @param aInteger An unsigned word sized integer.
+ * @return An RInteger representation of aInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(TUint aInteger)
+ {
+ RInteger self;
+ self.CreateNewL(2);
+ self.Construct(aInteger);
+ return self;
+ }