#include <OTPassword.hpp>

Public Types
enum	BlockSize { DEFAULT_SIZE = OT_DEFAULT_BLOCKSIZE, LARGER_SIZE = OT_LARGE_BLOCKSIZE }

Public Member Functions
EXPORT	OTPassword (BlockSize blockSize=DEFAULT_SIZE)

EXPORT	OTPassword (const OTPassword &rhs)

EXPORT	OTPassword (const char *input, uint32_t size, BlockSize blockSize=DEFAULT_SIZE)

EXPORT	OTPassword (const uint8_t *input, uint32_t size, BlockSize blockSize=DEFAULT_SIZE)

EXPORT	OTPassword (const void *input, uint32_t size, BlockSize blockSize=DEFAULT_SIZE)

EXPORT	~OTPassword ()

EXPORT OTPassword &	operator= (const OTPassword &rhs)

EXPORT bool	isPassword () const

EXPORT const uint8_t *	getPassword_uint8 () const

EXPORT const char *	getPassword () const

EXPORT uint8_t *	getPasswordWritable ()

EXPORT char *	getPasswordWritable_char ()

EXPORT int32_t	setPassword (const char *input, int32_t size)

EXPORT int32_t	setPassword_uint8 (const uint8_t *input, uint32_t size)

EXPORT bool	addChar (uint8_t c)

EXPORT int32_t	randomizePassword (uint32_t size=DEFAULT_SIZE)

EXPORT bool	isMemory () const

EXPORT const void *	getMemory () const

EXPORT const uint8_t *	getMemory_uint8 () const

EXPORT void *	getMemoryWritable ()

EXPORT int32_t	setMemory (const void *input, uint32_t size)

EXPORT int32_t	addMemory (const void *append, uint32_t size)

EXPORT int32_t	randomizeMemory (uint32_t size=DEFAULT_SIZE)

EXPORT uint32_t	getBlockSize () const

EXPORT bool	Compare (OTPassword &rhs) const

EXPORT uint32_t	getPasswordSize () const

EXPORT uint32_t	getMemorySize () const

EXPORT void	zeroMemory ()

EXPORT bool	SetSize (uint32_t size)

Static Public Member Functions
static EXPORT bool	randomizePassword_uint8 (uint8_t *destination, uint32_t size)

static EXPORT bool	randomizePassword (char *destination, uint32_t size)

static EXPORT bool	randomizeMemory_uint8 (uint8_t *destination, uint32_t size)

static EXPORT bool	randomizeMemory (void *destination, uint32_t size)

static EXPORT void	zeroMemory (uint8_t *szMemory, uint32_t size)

static EXPORT void	zeroMemory (void *vMemory, uint32_t size)

static EXPORT void *	safe_memcpy (void dest, uint32_t dsize, const void src, uint32_t ssize, bool zeroSource=false)

static EXPORT OTPassword *	CreateTextBuffer ()

Detailed Description

Definition at line 200 of file OTPassword.hpp.

Member Enumeration Documentation

enum opentxs::OTPassword::BlockSize

Enumerator
DEFAULT_SIZE
LARGER_SIZE

Definition at line 203 of file OTPassword.hpp.

                    {
         // (128 bytes max length for a password.)
         DEFAULT_SIZE = OT_DEFAULT_BLOCKSIZE,
         // Update: now 32767 bytes if you use this size.
         LARGER_SIZE = OT_LARGE_BLOCKSIZE
     };

Constructor & Destructor Documentation

opentxs::OTPassword::OTPassword ( OTPassword::BlockSize theBlockSize = DEFAULT_SIZE )

Definition at line 455 of file OTPassword.cpp.

     : size_(0)
     , isText_(true)
     , isBinary_(false)
     , isPageLocked_(false)
     , blockSize_(theBlockSize)
 {
     data_[0] = '\0';
     setPassword_uint8(reinterpret_cast<const uint8_t*>(""), 0);
 }

opentxs::OTPassword::OTPassword ( const OTPassword & rhs )

Definition at line 478 of file OTPassword.cpp.

     : size_(0)
     , isText_(rhs.isPassword())
     , isBinary_(rhs.isMemory())
     , isPageLocked_(false)
     , blockSize_(
           rhs.blockSize_) // The buffer has this size+1 as its static size.
 {
     if (isText_) {
         data_[0] = '\0';
         setPassword_uint8(rhs.getPassword_uint8(), rhs.getPasswordSize());
     }
     else if (isBinary_) {
         setMemory(rhs.getMemory_uint8(), rhs.getMemorySize());
     }
 }

opentxs::OTPassword::OTPassword	(	const char *	input,
		uint32_t	size,
		OTPassword::BlockSize	theBlockSize = `DEFAULT_SIZE`
	)

Definition at line 495 of file OTPassword.cpp.

     : size_(0)
     , isText_(true)
     , isBinary_(false)
     , isPageLocked_(false)
     , blockSize_(theBlockSize) // The buffer has this size+1 as its static size.
 {
     data_[0] = '\0';
 
     setPassword_uint8(reinterpret_cast<const uint8_t*>(szInput), nInputSize);
 }

opentxs::OTPassword::OTPassword	(	const uint8_t *	input,
		uint32_t	size,
		OTPassword::BlockSize	theBlockSize = `DEFAULT_SIZE`
	)

Definition at line 508 of file OTPassword.cpp.

     : size_(0)
     , isText_(true)
     , isBinary_(false)
     , isPageLocked_(false)
     , blockSize_(theBlockSize) // The buffer has this size+1 as its static size.
 {
     data_[0] = '\0';
 
     setPassword_uint8(szInput, nInputSize);
 }

opentxs::OTPassword::OTPassword	(	const void *	input,
		uint32_t	size,
		OTPassword::BlockSize	theBlockSize = `DEFAULT_SIZE`
	)

Definition at line 521 of file OTPassword.cpp.

     : size_(0)
     , isText_(false)
     , isBinary_(true)
     , isPageLocked_(false)
     , blockSize_(theBlockSize) // The buffer has this size+1 as its static size.
 {
     setMemory(vInput, nInputSize);
 }

opentxs::OTPassword::~OTPassword ( )

Definition at line 532 of file OTPassword.cpp.

 {
     if (size_ > 0) zeroMemory();
 }

Member Function Documentation

bool opentxs::OTPassword::addChar ( uint8_t c )

Definition at line 625 of file OTPassword.cpp.

 {
     OT_ASSERT(isPassword());
     if (getPasswordSize() < getBlockSize()) {
         data_[size_] = theChar;
         ++size_;
         data_[size_] = '\0';
         return true;
     }
     return false;
 }

int32_t opentxs::OTPassword::addMemory	(	const void *	append,
		uint32_t	size
	)

Definition at line 944 of file OTPassword.cpp.

 {
     OT_ASSERT(nullptr != vAppend);
 
     //  const char * szFunc = "OTPassword::addMemory";
 
     if (0 == nAppendSize) return 0;
 
     // If I'm currently at a 0 size, then call setMemory instead.
     //
     if (size_ == 0) return setMemory(vAppend, nAppendSize);
     //
     // By this point, I know I already have some memory allocated,
     // and I'm actually appending some other memory onto the end of it.
     //
     // Should already be set from the above setMemory call.
     OT_ASSERT(isBinary_);
 
     // Make sure total new size isn't larger than our block size
     //
     if ((nAppendSize + size_) > getBlockSize()) {
         // Truncated password beyond max size.
         nAppendSize = (getBlockSize() - size_);
     }
     //  OT_ASSERT(nAppendSize >= 0);
 
     if (0 == nAppendSize) return 0;
 
     // By this point, I know nAppendSize is larger than 0, AND that appending it
     // onto the
     // existing memory of this object will not exceed the total allowed block
     // size.
     //
     // Because we use setMemory when empty, and only use addMemory when we KNOW
     // something
     // is already there, therefore we know the page is already locked, so no
     // need to go
     // trying to lock it again.
 
     OTPassword::safe_memcpy(
         static_cast<void*>(&(data_[size_])),
         static_cast<uint32_t>(nAppendSize), // dest size is based on the source
                                             // size, but guaranteed to be >0 and
                                             // <=getBlockSize
         vAppend, static_cast<uint32_t>(nAppendSize)); // Since dest size is
                                                       // known to be src size or
                                                       // less (and >0) we use it
                                                       // as src size. (We may
                                                       // have truncated... and
                                                       // we certainly don't want
                                                       // to copy beyond our own
                                                       // truncation.)
 
     size_ += nAppendSize;
 
     return nAppendSize;
 }

bool opentxs::OTPassword::Compare ( OTPassword & rhs ) const

Definition at line 637 of file OTPassword.cpp.

 {
     OT_ASSERT(isPassword() || isMemory());
     OT_ASSERT(rhs.isPassword() || rhs.isMemory());
 
     if (isPassword() && !rhs.isPassword()) return false;
     if (isMemory() && !rhs.isMemory()) return false;
 
     const uint32_t nThisSize =
         isPassword() ? getPasswordSize() : getMemorySize();
     const uint32_t nRhsSize =
         rhs.isPassword() ? rhs.getPasswordSize() : rhs.getMemorySize();
 
     if (nThisSize != nRhsSize) return false;
 
     if (0 ==
         memcmp(isPassword() ? getPassword_uint8() : getMemory_uint8(),
                rhs.isPassword() ? rhs.getPassword_uint8()
                                 : rhs.getMemory_uint8(),
                rhs.isPassword() ? rhs.getPasswordSize() : rhs.getMemorySize()))
         return true;
 
     return false;
 }

OTPassword * opentxs::OTPassword::CreateTextBuffer ( )

static

Definition at line 429 of file OTPassword.cpp.

 {
     // Caller MUST delete!
 
     char throwaway_text[OT_DEFAULT_BLOCKSIZE];
     for (int32_t tt = 0; tt < OT_DEFAULT_BLOCKSIZE; ++tt) {
         throwaway_text[tt] = 'A'; // todo optimization...
     }
     throwaway_text[OT_DEFAULT_BLOCKSIZE - 1] = '\0';
     // We don't use the above memory, except to force OTPassword to create
     // itself
     // at a certain password size, so we can pass that buffer and size on to any
     // C-style function that needs them to "already exist."
     //
     OTPassword* pPassUserInput = new OTPassword(
         &(throwaway_text[0]), OT_DEFAULT_BLOCKSIZE - 1); // text mode.
     OT_ASSERT_MSG(nullptr != pPassUserInput,
                   "OTPassword::CreateTextBuffer: ASSERT: OTPassword * "
                   "pPassUserInput = new OTPassword(&(throwaway_text[0]), "
                   "OT_DEFAULT_BLOCKSIZE-1);");
     // Below this point, pPassUserInput must be returned, or deleted. (Or it
     // will leak.)
 
     return pPassUserInput;
 }

uint32_t opentxs::OTPassword::getBlockSize ( ) const

Definition at line 595 of file OTPassword.cpp.

 {
     uint32_t nReturn = 0;
 
     switch (blockSize_) {
     case OTPassword::DEFAULT_SIZE:
         nReturn = static_cast<uint32_t>(OT_DEFAULT_BLOCKSIZE);
         break;
     case OTPassword::LARGER_SIZE:
         nReturn = static_cast<uint32_t>(OT_LARGE_BLOCKSIZE);
         break;
     default:
         break;
     }
 
     return nReturn;
 }

const void * opentxs::OTPassword::getMemory ( ) const

Definition at line 577 of file OTPassword.cpp.

 {
     return reinterpret_cast<const void*>(getMemory_uint8());
 }

const uint8_t * opentxs::OTPassword::getMemory_uint8 ( ) const

Definition at line 582 of file OTPassword.cpp.

 {
     OT_ASSERT(isBinary_);
     return (size_ <= 0) ? nullptr : static_cast<const uint8_t*>(&(data_[0]));
 }

uint32_t opentxs::OTPassword::getMemorySize ( ) const

Definition at line 619 of file OTPassword.cpp.

 {
     OT_ASSERT(isBinary_);
     return size_;
 }

void * opentxs::OTPassword::getMemoryWritable ( )

Definition at line 589 of file OTPassword.cpp.

 {
     OT_ASSERT(isBinary_);
     return (size_ <= 0) ? nullptr : static_cast<void*>(&(data_[0]));
 }

const char * opentxs::OTPassword::getPassword ( ) const

Definition at line 547 of file OTPassword.cpp.

 {
     return reinterpret_cast<const char*>(getPassword_uint8());
 }

const uint8_t * opentxs::OTPassword::getPassword_uint8 ( ) const

Definition at line 554 of file OTPassword.cpp.

 {
     OT_ASSERT(isText_);
     return (size_ <= 0) ? reinterpret_cast<const uint8_t*>("") : &(data_[0]);
 }

uint32_t opentxs::OTPassword::getPasswordSize ( ) const

Definition at line 613 of file OTPassword.cpp.

 {
     OT_ASSERT(isText_);
     return size_;
 }

uint8_t * opentxs::OTPassword::getPasswordWritable ( )

Definition at line 560 of file OTPassword.cpp.

 {
     OT_ASSERT(isText_);
     return (size_ <= 0)
                ? nullptr
                : static_cast<uint8_t*>(static_cast<void*>(&(data_[0])));
 }

char * opentxs::OTPassword::getPasswordWritable_char ( )

Definition at line 568 of file OTPassword.cpp.

 {
     OT_ASSERT(isText_);
     return (size_ <= 0) ? nullptr
                         : static_cast<char*>(static_cast<void*>(&(data_[0])));
 }

bool opentxs::OTPassword::isMemory ( ) const

Definition at line 542 of file OTPassword.cpp.

 {
     return isBinary_;
 }

bool opentxs::OTPassword::isPassword ( ) const

Definition at line 537 of file OTPassword.cpp.

 {
     return isText_;
 }

OTPassword & opentxs::OTPassword::operator= ( const OTPassword & rhs )

Definition at line 466 of file OTPassword.cpp.

 {
     if (rhs.isPassword()) {
         setPassword_uint8(rhs.getPassword_uint8(), rhs.getPasswordSize());
     }
     else if (rhs.isMemory()) {
         setMemory(rhs.getMemory_uint8(), rhs.getMemorySize());
     }
 
     return *this;
 }

int32_t opentxs::OTPassword::randomizeMemory ( uint32_t size = DEFAULT_SIZE )

Definition at line 890 of file OTPassword.cpp.

 {
     uint32_t nSize = nNewSize;
 
     // Wipe whatever was in there before.
     //
     if (size_ > 0) zeroMemory();
 
     isBinary_ = true;
     isText_ = false;
 
     if (0 == nSize) return 0;
 
     // Make sure no input size is larger than our block size
     //
     if (nSize > getBlockSize())
         nSize = getBlockSize(); // Truncated password beyond max size.
 
 #ifndef _WIN32
     //
     // Lock the memory page, before we randomize 'size bytes' of the data.
     // (If it's not already locked, which I doubt it will be.)
     //
     if (!isPageLocked_) // it won't be locked already, since we just zero'd it
                         // (above.) But I check this anyway...
     {
         if (ot_lockPage(static_cast<void*>(&(data_[0])), getBlockSize())) {
             isPageLocked_ = true;
         }
         else {
             otErr << __FUNCTION__
                   << ": Error: Failed attempting to lock memory page.\n";
         }
     }
 #endif
 
     //
     if (!OTPassword::randomizeMemory_uint8(&(data_[0]), nSize)) {
         // randomizeMemory (above) already logs, so I'm not logging again twice
         // here.
         //
         zeroMemory();
         return -1;
     }
 
     size_ = nSize;
 
     return size_;
 }

bool opentxs::OTPassword::randomizeMemory	(	void *	destination,
		uint32_t	size
	)

static

Definition at line 874 of file OTPassword.cpp.

 {
     return OTPassword::randomizeMemory_uint8(
         reinterpret_cast<uint8_t*>(szDestination), nNewSize);
 }

bool opentxs::OTPassword::randomizeMemory_uint8	(	uint8_t *	destination,
		uint32_t	size
	)

static

Definition at line 881 of file OTPassword.cpp.

 {
     return OTCrypto::It()->RandomizeMemory(szDestination, nNewSize);
 }

int32_t opentxs::OTPassword::randomizePassword ( uint32_t size = DEFAULT_SIZE )

Definition at line 823 of file OTPassword.cpp.

 {
     uint32_t nSize = nNewSize;
 
     // Wipe whatever was in there before.
     //
     if (size_ > 0) zeroMemory();
 
     isBinary_ = false;
     isText_ = true;
 
     if (0 == nSize) return 0;
 
     // Make sure no input size is larger than our block size
     //
     if (nSize > getBlockSize())
         nSize = getBlockSize(); // Truncated password beyond max size.
 #ifndef _WIN32
     //
     // Lock the memory page, before we randomize 'size bytes' of the data.
     // (If it's not already locked, which I doubt it will be.)
     //
     if (!isPageLocked_) // it won't be locked already, since we just zero'd it
                         // (above.) But I check this anyway...
     {
         if (ot_lockPage(static_cast<void*>(&(data_[0])), getBlockSize())) {
             isPageLocked_ = true;
         }
         else {
             otErr << __FUNCTION__
                   << ": Error: Failed attempting to lock memory page.\n";
         }
     }
 #endif
 
     //
     if (!OTPassword::randomizePassword_uint8(&(data_[0]),
                                              static_cast<int32_t>(nSize + 1))) {
         // randomizeMemory (above) already logs, so I'm not logging again twice
         // here.
         //
         zeroMemory();
         return -1;
     }
 
     size_ = nSize;
 
     return size_;
 }

bool opentxs::OTPassword::randomizePassword	(	char *	destination,
		uint32_t	size
	)

static

Definition at line 785 of file OTPassword.cpp.

 {
     return OTPassword::randomizePassword_uint8(
         reinterpret_cast<uint8_t*>(szDestination), nNewSize);
 }

bool opentxs::OTPassword::randomizePassword_uint8	(	uint8_t *	destination,
		uint32_t	size
	)

static

Definition at line 792 of file OTPassword.cpp.

 {
     OT_ASSERT(nullptr != szDestination);
     OT_ASSERT(nNewSize > 0);
 
     //  const char * szFunc = "OTPassword::randomizePassword(static)";
 
     if (OTPassword::randomizeMemory_uint8(szDestination, nNewSize)) {
 
         // This loop converts an array of binary bytes into the
         // same array, where each byte is translated to a byte
         // between the values of 33 and 122 (visible ASCII.)
         //
         for (uint32_t i = 0; i < nNewSize; ++i) {
             uint8_t temp = (((szDestination[i]) % 89) + 33);
             szDestination[i] = temp;
         }
 
         // Add the nullptr terminator...
         //
         szDestination[nNewSize - 1] = '\0';
 
         return true;
     }
     return false;
 }

void * opentxs::OTPassword::safe_memcpy	(	void *	dest,
		uint32_t	dsize,
		const void *	src,
		uint32_t	ssize,
		bool	zeroSource = `false`
	)

static

Definition at line 357 of file OTPassword.cpp.

 {
     // Make sure they aren't null.
     OT_ASSERT(nullptr != dest);
     OT_ASSERT(nullptr != src);
 
     // Make sure they aren't the same pointer.
     OT_ASSERT(src != dest);
 
     // Make sure it will fit.
     OT_ASSERT_MSG(src_length <= dest_size,
                   "ASSERT: safe_memcpy: destination buffer too small.\n");
 
     // Make sure they don't overlap.
     // First assert does the beginning of the string, makes sure it's not within
     // the bounds of the destination
     // string. Second assert does the same thing for the end of the string.
     // Finally a third is needed to make sure
     // we're not in a situation where the beginning is less than the dest
     // beginning, yet the end is also more than
     // the dest ending!
     //
     OT_ASSERT_MSG(
         false ==
             ((static_cast<const uint8_t*>(src) > static_cast<uint8_t*>(dest)) &&
              (static_cast<const uint8_t*>(src) <
               (static_cast<uint8_t*>(dest) + dest_size))),
         "ASSERT: safe_memcpy: Unexpected memory overlap, start of src.\n");
     OT_ASSERT_MSG(
         false == (((static_cast<const uint8_t*>(src) + src_length) >
                    static_cast<uint8_t*>(dest)) &&
                   ((static_cast<const uint8_t*>(src) + src_length) <
                    (static_cast<uint8_t*>(dest) + dest_size))),
         "ASSERT: safe_memcpy: Unexpected memory overlap, end of src.\n");
     OT_ASSERT(false == ((static_cast<const uint8_t*>(src) <=
                          static_cast<uint8_t*>(dest)) &&
                         ((static_cast<const uint8_t*>(src) + src_length) >=
                          (static_cast<uint8_t*>(dest) + dest_size))));
 
 #ifdef _WIN32
     bool bSuccess = (0 == memcpy_s(dest, static_cast<size_t>(dest_size), src,
                                    static_cast<size_t>(src_length)));
 #else
     bool bSuccess =
         (memcpy(dest, src, static_cast<size_t>(src_length)) == dest);
 #endif
 
     if (bSuccess) {
         if (bZeroSource) {
             OTPassword::zeroMemory(const_cast<void*>(src), src_length);
         }
 
         return dest;
     }
 
     return nullptr;
 }

int32_t opentxs::OTPassword::setMemory	(	const void *	input,
		uint32_t	size
	)

Definition at line 1005 of file OTPassword.cpp.

 {
     OT_ASSERT(nullptr != vInput);
 
     // Wipe whatever was in there before.
     //
     if (size_ > 0) zeroMemory();
 
     isBinary_ = true;
     isText_ = false;
 
     if (0 == nInputSize) return 0;
 
     // Make sure no input size is larger than our block size
     //
     if (nInputSize > getBlockSize())
         nInputSize = getBlockSize(); // Truncated password beyond max size.
 
 #ifndef _WIN32
     //
     // Lock the memory page, before we copy the data over.
     // (If it's not already locked, which I doubt it will be.)
     //
     if (!isPageLocked_) // it won't be locked already, since we just zero'd it
                         // (above.) But I check this anyway...
     {
         if (ot_lockPage(static_cast<void*>(&(data_[0])), getBlockSize())) {
             isPageLocked_ = true;
         }
         else {
             otErr << __FUNCTION__
                   << ": Error: Failed attempting to lock memory page.\n";
         }
     }
 #endif
 
     OTPassword::safe_memcpy(static_cast<void*>(&(data_[0])),
                             // dest size is based on the source
                             // size, but guaranteed to be >0 and
                             // <=getBlockSize
                             static_cast<uint32_t>(nInputSize),
                             // Since dest size is known
                             // to be src size or less
                             // (and >0) we use it as src
                             // size. (We may have
                             // truncated... and we
                             // certainly don't want to
                             // copy beyond our own
                             // truncation.)
                             vInput, static_cast<uint32_t>(nInputSize));
 
     size_ = nInputSize;
     return size_;
 }

int32_t opentxs::OTPassword::setPassword	(	const char *	input,
		int32_t	size
	)

Definition at line 665 of file OTPassword.cpp.

 {
     return static_cast<int32_t>(
         setPassword_uint8(reinterpret_cast<const uint8_t*>(szInput),
                           static_cast<uint32_t>(nInputSize)));
 }

int32_t opentxs::OTPassword::setPassword_uint8	(	const uint8_t *	input,
		uint32_t	size
	)

Definition at line 674 of file OTPassword.cpp.

 {
     OT_ASSERT(nullptr != szInput);
 
     // cppcheck-suppress variableScope
     const char* szFunc = "OTPassword::setPassword";
 
     // Wipe whatever was in there before.
     //
     if (size_ > 0) zeroMemory();
 
     isBinary_ = false;
     isText_ = true;
 
     if (0 == nInputSize) return 0;
 
     // Make sure no input size is larger than our block size
     //
     if (nInputSize > getBlockSize())
         nInputSize = getBlockSize(); // Truncated password beyond max size.
 
     // The szInput string passed into this function should never
     // be a different size than what is passed in. For example it shouldn't
     // be SMALLER than what the user claims either. If it is, we error out.
     //
     if (OTString::safe_strlen(reinterpret_cast<const char*>(szInput),
                               static_cast<size_t>(nInputSize)) <
         static_cast<size_t>(nInputSize)) {
         otErr
             << szFunc
             << ": ERROR: string length of szInput did not match nInputSize.\n";
         return (-1);
     }
 
 #ifndef _WIN32
 
     //
     // Lock the memory page, before we copy the data over.
     // (If it's not already locked, which I doubt it will be.)
     //
     // it won't be locked already, since we just zero'd it
     // (above.) But I check this anyway...
     if (!isPageLocked_) {
         if (ot_lockPage(static_cast<void*>(&(data_[0])), getBlockSize())) {
             isPageLocked_ = true;
         }
         else {
             otErr << szFunc
                   << ": Error: Failed attempting to lock memory page.\n";
         }
     }
 #endif
 
 #ifdef _WIN32
     strncpy_s(reinterpret_cast<char*>(data_), (1 + nInputSize),
               reinterpret_cast<const char*>(szInput), nInputSize);
 #else
     strncpy(reinterpret_cast<char*>(data_),
             reinterpret_cast<const char*>(szInput), nInputSize);
 #endif
 
     // force a null terminator in the 129th byte (at index 128.)
     // (Or at the 6th byte (at index 5), if the size is 5 bytes int64_t.)
     //
     data_[nInputSize] = '\0';
     size_ = nInputSize;
 
     return size_;
 }

bool opentxs::OTPassword::SetSize ( uint32_t size )

Definition at line 758 of file OTPassword.cpp.

 {
     if (isBinary_) {
         if (uSize > getBlockSize())
             uSize = getBlockSize(); // Truncated password beyond max size.
         size_ = uSize;
         return true;
     }
     else if (isText_) {
         // Cannot be as much as the blocksize,
         // because no room for null-terminator.
         if (uSize >= getBlockSize()) {
             uSize = getBlockSize() - 1; // Truncated password to blocksize-1.
         }
         // The actual null-terminator.
         data_[uSize] = '\0';
         // If size is 3, the terminator is at
         size_ = uSize;
         // data_[3] (which is the 4th byte.)
         return true;
     }
     otErr << __FUNCTION__ << ": Error: isBinary_ and isText_ are both "
                              "false. (Should never happen.)\n";
     return false;
 }

void opentxs::OTPassword::zeroMemory ( )

Definition at line 281 of file OTPassword.cpp.

 {
     size_ = 0;
 
     OTPassword::zeroMemory(static_cast<void*>(&(data_[0])),
                            static_cast<uint32_t>(getBlockSize()));
 
 //
 #ifndef _WIN32
     // UNLOCK the page, now that we're AFTER the point where
     // the memory was safely ZERO'd out.
     //
     if (isPageLocked_) {
         if (ot_unlockPage(static_cast<void*>(&(data_[0])),
                           static_cast<uint32_t>(getBlockSize()))) {
             isPageLocked_ = false;
         }
         else
             otErr << "OTPassword::zeroMemory: Error: Memory page was locked, "
                      "but then failed to unlock it.\n";
     }
 #endif
 }

void opentxs::OTPassword::zeroMemory	(	uint8_t *	szMemory,
		uint32_t	size
	)

static

Definition at line 319 of file OTPassword.cpp.

 {
 #ifdef _WIN32
 
     //
     SecureZeroMemory(szMemory, theSize);
 
 // NOTE: Both SecureZeroMemory, and the pragma solution commented-out below,
 // are acceptable for Windows. I put both here for my notes.
 //
 //#pragma optimize("", off)
 //    memset(szMemory, 0, theSize);
 //#pragma optimize("", on)
 
 // Dr. UNIX, I presume? So, we meet again...
 #else
     ot_secure_memset(szMemory, static_cast<uint8_t>(0), theSize);
 #endif
 }

void opentxs::OTPassword::zeroMemory	(	void *	vMemory,
		uint32_t	size
	)

static

Definition at line 306 of file OTPassword.cpp.

 {
     //  OT_ASSERT_MSG((nullptr != vMemory) && (theSize >
     // 0),"OTPassword::zeroMemory: ASSERT: vMemory is nullptr or theSize is
     // 0.");
 
     if ((nullptr != vMemory) && (theSize > 0)) {
         uint8_t* szMemory = static_cast<uint8_t*>(vMemory);
         OTPassword::zeroMemory(szMemory, theSize);
     }
 }

The documentation for this class was generated from the following files:

/usr/local/src/opentxs/include/opentxs/core/crypto/OTPassword.hpp
/usr/local/src/opentxs/src/core/crypto/OTPassword.cpp

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation