Example #1
0
int feistelDecrypt( const std::string &strDesKey, std::string &strPlain, const std::string &strCipher )
{
    const int LENGTH = 8;
    
    int iLength = strCipher.length();
    if( iLength % LENGTH != 0 )
        return -1;

    char szDesKey[ LENGTH ];
    memset( szDesKey, 0, LENGTH );
    strDesKey.copy( szDesKey, LENGTH );
    
    char subKey[16][4];
    genSubKey( szDesKey, subKey );

    char plain[  LENGTH ];
    char cipher[ LENGTH ];
    strPlain.clear();
    
    int iLoop = iLength / LENGTH;
    for( int i = 0; i < iLoop; i++ )
    {
        strCipher.copy( cipher, LENGTH, i * LENGTH );
        feistelDecryptUnit( 16, subKey, plain, cipher );
        strPlain.append( plain, LENGTH );
    }
    
    bool bPadEight = true;
    for( int i = 0; i < LENGTH; i++ )
    {
        if( plain[ i ] != LENGTH )
        {
            bPadEight = false;
            break;
        }
    }
    
    if( bPadEight )    // 填充了 8 个字节
    {
        strPlain.erase( iLength - LENGTH );
    }
    else
    {
        int iValue = 7;
        for( int i = 1; i < LENGTH; i++ )
        {
            if( plain[ i ] == iValue ) continue;
            iValue = 7 - i;
        }
        
        if( iValue > 0 )
        {
            strPlain.erase( iLength - iValue );
        }
    }
    
    return 0;
}
Example #2
0
/*static*/ void rrdb_client_impl::generate_key(dsn::blob& key, const std::string& hash_key, const std::string& sort_key)
{
    int len = 4 + hash_key.size() + sort_key.size();
    char* buf = new char[len];
    *(int*)buf = hash_key.size();
    hash_key.copy(buf + 4, hash_key.size(), 0);
    sort_key.copy(buf + 4 + hash_key.size(), sort_key.size(), 0);
    std::shared_ptr<char> buffer(buf);
    key.assign(buffer, 0, len);
}
Example #3
0
void TripleDESCryptor::InitKeys(const std::string& key24)
{
	BOOST_ASSERT(key24.size() == KEY_LEN*3);
	DES_cblock k;
	key24.copy((char*)&k, KEY_LEN);
	DES_set_key_unchecked(&k, &ks1_);
	key24.copy((char*)&k, KEY_LEN, KEY_LEN);
	DES_set_key_unchecked(&k, &ks2_);
	key24.copy((char*)&k, KEY_LEN, KEY_LEN*2);
	DES_set_key_unchecked(&k, &ks3_);
}
void Element::unserialize(std::string &buffer) {
	buffer.copy((char*)&key,sizeof(Key));
	buffer.erase(0,sizeof(Key));

	buffer.copy((char*)&dataSize,sizeof(DataSize));
	buffer.erase(0,sizeof(DataSize));

	data = new char[dataSize];

	buffer.copy((char*)data,dataSize);
	buffer.erase(0,dataSize);
}
Example #5
0
 void get_options(crack_opt_t *opts) {
     memset(opts, 0, sizeof(crack_opt_t));
     
     opts->start_cbn  = start_cbn;
     opts->end_cbn    = end_cbn;
     opts->total_cbn  = total_cbn;
     opts->thread_cbn = (total_cbn/thread_cnt);
     opts->thread_cnt = thread_cnt;
     
     alphabet.copy(opts->alphabet, 128, 0);
     start_pwd.copy(opts->start_pwd, MAX_PWD, 0);
     end_pwd.copy(opts->end_pwd, MAX_PWD, 0);
 }
Example #6
0
// We'll allow our audioQueue to be significantly larger than our video queue
// This is safe because A) audio is a lot smaller, so it isn't a big deal to hold on to a lot of it and
// B) our audio sample rate is typically 20 msec packets; video is anywhere from 33 to 100 msec (30 to 10 fps)
// Allowing the audio queue to hold more will help prevent loss of data when the video framerate is low.
ExternalOutput::ExternalOutput(const std::string& outputUrl) : fec_receiver_(this), audioQueue_(600, 60), videoQueue_(120, 60), inited_(false), video_stream_(NULL), audio_stream_(NULL),
    firstVideoTimestamp_(-1), firstAudioTimestamp_(-1), firstDataReceived_(-1), videoOffsetMsec_(-1), audioOffsetMsec_(-1), vp8SearchState_(lookingForStart)
{
    ELOG_DEBUG("Creating output to %s", outputUrl.c_str());

    // TODO these should really only be called once per application run
    av_register_all();
    avcodec_register_all();


    context_ = avformat_alloc_context();
    if (context_==NULL){
        ELOG_ERROR("Error allocating memory for IO context");
    } else {

        outputUrl.copy(context_->filename, sizeof(context_->filename),0);

        context_->oformat = av_guess_format(NULL,  context_->filename, NULL);
        if (!context_->oformat){
            ELOG_ERROR("Error guessing format %s", context_->filename);
        } else {
            context_->oformat->video_codec = AV_CODEC_ID_VP8;
            context_->oformat->audio_codec = AV_CODEC_ID_NONE; // We'll figure this out once we start receiving data; it's either PCM or OPUS
        }
    }

    unpackagedBufferpart_ = unpackagedBuffer_;
    lastFullIntraFrameRequest_ = 0;
    sinkfbSource_ = this;
    fbSink_ = NULL;
    unpackagedSize_ = 0;
}
Example #7
0
RecordType getRecordType(const std::string& record)
{
    // the record type is the first two characters of the record
    if(record.size() < 2)
    {
        std::cerr << "Error: record does not have a valid record-type tag" << std::endl;
        std::cerr << "Record: " << record << std::endl;
        exit(EXIT_FAILURE);
    }

    char recordTag[RECORD_TAG_SIZE];
    record.copy(recordTag, RECORD_TAG_SIZE);

    if(strncmp(recordTag, HEADER_TAG, RECORD_TAG_SIZE) == 0)
    {
        return RT_HEADER;
    }

    if(strncmp(recordTag, VERTEX_TAG, RECORD_TAG_SIZE) == 0)
    {
        return RT_VERTEX;
    }

    if(strncmp(recordTag, EDGE_TAG, RECORD_TAG_SIZE) == 0)
    {
        return RT_EDGE;
    }

    // Unknown tag
    std::cerr << "Error: Unknown ASQG file record tag: " << recordTag << std::endl;
    exit(EXIT_FAILURE);
}
Example #8
0
static void CheckAddressIsInSet(const std::string& if_name, bool unicast,
                                const std::set<in_addr_t>& addrs) {
  ifreq ifr;
  memset(&ifr, 0, sizeof(ifr));
  ifr.ifr_addr.sa_family = AF_INET;
  if_name.copy(ifr.ifr_name, IFNAMSIZ - 1);

  int fd = socket(AF_INET, SOCK_DGRAM, 0);
  ASSERT_TRUE(fd != -1);

  int request = SIOCGIFADDR;
  if (!unicast) {
    // For non-unicast, the specific ioctl to use depends on whether the IFF_BROADCAST flag is set.
    ASSERT_EQ(0, ioctl(fd, SIOCGIFFLAGS, &ifr)) << if_name << ' ' << strerror(errno);
    request = ((ifr.ifr_flags & IFF_BROADCAST) != 0) ? SIOCGIFBRDADDR : SIOCGIFDSTADDR;
  }

  ASSERT_EQ(0, ioctl(fd, request, &ifr)) << if_name << ' ' << strerror(errno);
  close(fd);

  sockaddr_in* sock = reinterpret_cast<sockaddr_in*>(&ifr.ifr_addr);
  in_addr_t addr = sock->sin_addr.s_addr;

  EXPECT_TRUE(addrs.find(addr) != addrs.end()) << if_name << ' ' << std::hex << ntohl(addr);
}
Example #9
0
void matrix::set_sequences(std::string sequence1, std::string sequence2) {
// dont want to maintain a different version for vc++ and g++
#pragma warning( disable : 4996 )
	if(this->sequence1)
		delete[] this->sequence1;
	this->sequence1 = new char [sequence1.size()+1];
	sequence1.copy(this->sequence1, sequence1.size()+1, 0);

	if(this->sequence2)
		delete[] this->sequence2;
	this->sequence2 = new char [sequence2.size()+1];
	sequence2.copy(this->sequence2, sequence2.size()+1, 0);

	rows = sequence1.size() + 1;
	cols = sequence2.size() + 1;
}
Example #10
0
void network::writeMessage(std::string s) {
    char input[1024];
    bzero(input,1024);
    s.copy(input,1024,0);
    sendto(sockfd, input, sizeof(input), 0,
           (struct sockaddr*)&name, sizeof(name));
}
Example #11
0
TimeSec ID_SOYAL_DL_Week::GetTimeSect(std::string time_str)
{
	char time_hh[3]="",time_mm[3]="";
	TimeSec timesec;
	memset(&timesec,0,sizeof timesec);
    if(time_str.length()==8)
	{
    	time_str.copy(time_hh,2);
    	time_str.copy(time_mm,2,2);
    	timesec.begin_time = atoi(time_hh)*60 + atoi(time_mm);		// 开始时间(分钟)		
    	time_str.copy(time_hh,2,4);
    	time_str.copy(time_mm,2,6);
    	timesec.end_time = atoi(time_hh)*60 + atoi(time_mm);		// 结束时间(分钟)
    }
	return timesec;
}
Example #12
0
void textadventure::bcrypt::performHash(
  uvpp::Loop& loop,
  std::string plaintext,
  std::string salt,
  std::function<void (std::string)> callback
) {
  loop.doWork(
    [plaintext, salt]() {
      auto hash = new char[BCRYPT_HASHSIZE];
      char csalt[BCRYPT_HASHSIZE];
      auto csaltLength = salt.copy(csalt, salt.length(), 0);
      csalt[csaltLength] = '\0';

      auto cplaintext = plaintext.c_str();

      bcrypt_hashpw(cplaintext, csalt, hash);
      auto str = new std::string(hash);

      delete hash;

      return str;
    },
    [callback](void* result) {
      auto str = std::unique_ptr<std::string>(
        reinterpret_cast<std::string*>(result)
      );
      callback(*str);
    }
  );
}
Example #13
0
 void setData(int aWidth, int aHeight, std::string const & newData) {
     if ( data ) delete data;
     width = aWidth;
     height = aHeight;
     data = new unsigned char[ dataSize() ];
     newData.copy( reinterpret_cast<char *>(data), dataSize() );
 }
Example #14
0
void BNode::unserialize(std::string &buffer) {
	buffer.copy((char*)&level,sizeof(Level));
	buffer.erase(0,sizeof(Level));

	//buffer.copy((char*)&registerCounter,sizeof(RegisterCounter));
	//buffer.erase(0,sizeof(RegisterCounter));
}
bool FileSystem::deleteFromAddress(std::string address, std::string remoteFile)
{
    int connectionToServer; //TCP connect to introducer/other nodes

    // printf("Local file: %s\n", localFile.c_str());
    // printf("Remote file: %s\n", remoteFile.c_str());

    logFile << "Deleting -  Connecting to "<< address << "..." << std::endl;

    int ret = connect_to_server(address.c_str(), port, &connectionToServer);
    if(ret!=0)
    {
        logFile <<"ERROR putToAddress: Cannot connect to "<<address<< std::endl;
        std::cout <<"ERROR putToAddress: Cannot connect to "<<address<< std::endl;
        return false;
    }
    else{

        Message_fs msg;
        msg.type = MSG_DELETE;

        memset(msg.filename, '\0', 200);
        remoteFile.copy(msg.filename, remoteFile.length());
        msg.filename[remoteFile.length()+1] = '\0';
        msg.size = 0;

        write(connectionToServer, &msg, sizeof(Message_fs) );   

        close(connectionToServer);
        return true;
    }   
}
void scottgs::verseCounter()
{
	// =========================
	// worker function
	// =========================
	int rank;
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	std::cout << "scottgs::verseCounter["<< rank << "], waiting for work" << std::endl;

	char msg[scottgs::LINE_MESSAGE_SIZE];
  	MPI_Status status;

	while (1) 
	{
		// Receive a message from the master
		MPI_Recv(msg, 			/* message buffer */
			scottgs::LINE_MESSAGE_SIZE, 	/* buffer size */
			MPI_CHAR, 		/* data item is an integer */
			0,  			/* Receive from master */
			MPI_ANY_TAG,		
		     	MPI_COMM_WORLD, 	/* default communicator */
		     	&status);

		// Check if we have been terminated by the master
		// exit from the worker loop
		if (status.MPI_TAG == scottgs::TERMINATE) 
		{
			std::cout << "scottgs::verseCounter["<< rank << "], recieved terminate signal" << std::endl;
			return;
		}
		
		const int index = status.MPI_TAG;
		
		// Convert the message into a string for parse work
		std::string line(msg);
#if GJS_DEBUG_PRINT			
		std::cout << "scottgs::verseCounter[" << rank << "], recieved (" << line << "), status = " << index << std::endl;
#endif		  

		// We have now built up a term=count comma separated list
		// We can send the result back
		const std::string resultLine = scottgs::workerCountWords(line, rank);
		const size_t length = resultLine.size();
		char resultMsg[scottgs::RESULT_MESSAGE_SIZE];
		resultLine.copy(resultMsg,length);
		resultMsg[length] = '\0';
#if GJS_DEBUG_PRINT			
		std::cout << "scottgs::verseCounter[" << rank << "], result list (" << resultLine << ")" << std::endl;
#endif		  
		MPI_Send(resultMsg,           /* message buffer */
		     scottgs::RESULT_MESSAGE_SIZE,            /* buffer size */
		     MPI_CHAR,          	/* data item is an integer */
		     0,              		/* destination process rank, the master */
		     index,  			/* user chosen message tag */
		     MPI_COMM_WORLD);   	/* default communicator */
		
	} // end of an infinite loop
	return;
}
Example #17
0
void Magick::Options::fileName(const std::string &fileName_)
{
  fileName_.copy(_imageInfo->filename,MagickPathExtent-1);
  if (fileName_.length() > MagickPathExtent-1)
    _imageInfo->filename[MagickPathExtent-1]=0;
  else
    _imageInfo->filename[fileName_.length()]=0;
}
Example #18
0
void 
SocketConnection::beginWrite(const std::string& str, boost::any tag /* = NULL */)
{
    size_t len = str.size();
    boost::shared_array<char> data(new char[len]);
    str.copy(data.get(), len);
    Proactor::instance()->beginWrite(this->shared_from_this(), boost::bind(&Connection::onWriteComplete,this,_1,_2), Buffer<char>(data, len, len), tag);
}
bool FileSystem::getFromAddress(std::string address, std::string localFile, std::string remoteFile)
{
    int connectionToServer; //TCP connect to introducer/other nodes

    logFile << "getFromAddress: Connecting to "<< address << "..." << std::endl;

    int ret = connect_to_server(address.c_str(), port, &connectionToServer);
    if(ret!=0)
    {
        logFile <<"ERROR getFromAddress: Cannot connect to "<<address<< std::endl;
        std::cout <<"ERROR getFromAddress: Cannot connect to "<<address<< std::endl;
        return false;
    }
    else{
        
        Message_fs msg;
        msg.type = MSG_GET;
        memset(msg.filename, '\0', 200);
        remoteFile.copy(msg.filename, remoteFile.length());

        write(connectionToServer, &msg, sizeof(Message_fs)); // Send filename
        read (connectionToServer, &msg, sizeof(Message_fs)); // Receive size

        if (msg.size == 0)
        {
            std::cout << "File does not exist: " << remoteFile << std::endl;
            close(connectionToServer);
            return false;
        }
        else
        {
            char * buffer = new char [msg.size];

            //size_t ret = read(connectionToServer, buffer,  msg.size);
            size_t ret =splitRead( connectionToServer, buffer, msg.size );
            // std::cout << "getFromAddress: Received: " << ret <<" of "<<msg.size << std::endl;

            std::ofstream file(localFile, std::ofstream::binary);

            if (!file.good())
            {
                std::cout << "Could not open file: " << localFile << std::endl;
                logFile << "Could not open file: " << localFile << std::endl;
                return false;
            }

            file.write(buffer, msg.size); 
            file.close();  

            delete buffer;

            close(connectionToServer);
            return true;
        }        
    }
}
bool FileSystem::putToAddress(std::string address, std::string localFile, std::string remoteFile)
{
    int connectionToServer; //TCP connect to introducer/other nodes

    // printf("Local file: %s\n", localFile.c_str());
    // printf("Remote file: %s\n", remoteFile.c_str());

    std::ifstream file(localFile, std::ifstream::binary);

    if (!file.good())
    {
        std::cout << "putToAddress: Could not open file: " << localFile << std::endl;
        logFile << "putToAddress: Could not open file: " << localFile << std::endl;
        return false;
    }

    logFile << "putToAddress: Connecting to "<< address << "..." << std::endl;

    int ret = connect_to_server(address.c_str(), port, &connectionToServer);
    if(ret!=0)
    {
        logFile <<"ERROR putToAddress: Cannot connect to "<<address<< std::endl;
        std::cout <<"ERROR putToAddress: Cannot connect to "<<address<< std::endl;
        file.close(); 
        return false;
    }
    else{

        // Read the file
        file.seekg (0, file.end);
        int length = file.tellg();
        file.seekg (0, file.beg);        

        char * buffer = new char [length];

        file.read (buffer,length);

        Message_fs msg;
        msg.type = MSG_PUT;

        memset(msg.filename, '\0', 200);
        remoteFile.copy(msg.filename, remoteFile.length());
        msg.filename[remoteFile.length()+1] = '\0';
        msg.size = length;
        //std::string test = msg.filename;
        //std::cout << "test: :" << test << std::endl;

        write(connectionToServer, &msg, sizeof(Message_fs) );
        write(connectionToServer, buffer, length);     

        close(connectionToServer);
        delete buffer;
        file.close(); 
        return true;
    }   
}
void LeafNode::unserialize(std::string &buffer) {
        BNode::unserialize(buffer);
        RegisterCounter registerCounter;

        buffer.copy((char*)&registerCounter,sizeof(RegisterCounter));
    buffer.erase(0,sizeof(RegisterCounter));

        buffer.copy((char*)&prevNode,sizeof(Offset));
        buffer.erase(0,sizeof(Offset));

        buffer.copy((char*)&nextNode,sizeof(Offset));
        buffer.erase(0,sizeof(Offset));


        for(RegisterCounter i = 0 ; i < registerCounter; i++){
                Element* el = new Element();
                el->unserialize(buffer);
                elements.push_back(el);
        }
}
Example #22
0
/************************
 *	Purpose / what it does
 *		Converts the given string and sets it to the object's 'line' character array
 *	
 *	Parameters
 *		string	a_charArray		The line to be set
 *		bool	a_getWords		Default true. Whether or not to process the words in the line
 ************************/
void Line::setLine(std::string a_newLine, bool a_getWords)
{
	if(a_newLine[0] == 0 && a_newLine.size() == 1)
		numChars	= 0;
	else
		numChars	= a_newLine.size();
	a_newLine.copy(line, numChars);

	if(a_getWords)
		getWords();
}
Example #23
0
    void setString(MYSQL_BIND& bind, unsigned long& length,
      const std::string& data)
    {
      reserve(bind, data.size());
      data.copy(static_cast<char*>(bind.buffer), data.size());

      bind.buffer_type = MYSQL_TYPE_VAR_STRING;
      bind.is_null = 0;
      length = data.size();
      bind.length = &length;
    }
Example #24
0
PatMat::PatElmt_::PatElmt_(const std::string& str)
:
    pCode_(PC_Null),
    index_(1),
    pNext_(EOP)
{
    switch (str.length())
    {
        case 0:
            pCode_ = PC_Null;
            break;
        case 1:
            pCode_ = PC_Char;
            val.Char = str[0];
            break;
        case 2:
            pCode_ = PC_String_2;
            str.copy(val.Str2, 2);
            break;
        case 3:
            pCode_ = PC_String_3;
            str.copy(val.Str3, 3);
            break;
        case 4:
            pCode_ = PC_String_4;
            str.copy(val.Str4, 4);
            break;
        case 5:
            pCode_ = PC_String_5;
            str.copy(val.Str5, 5);
            break;
        case 6:
            pCode_ = PC_String_6;
            str.copy(val.Str6, 6);
            break;
        default:
            pCode_ = PC_String;
            val.Str = new std::string(str);
            break;
    }
}
Example #25
0
bool astyle(std::string &content, const char *options)
{
    // allocate internal buffer
    size_t len = content.size();
    char *textIn = new(std::nothrow) char[len + 1];
    if (!textIn)
        return false;
    // copy to internal buffer
#ifdef WIN32
#pragma warning(push)  // FIX
#pragma warning(disable: 4996)
    size_t copied = content.copy(textIn, len);
#pragma warning(pop)
#else
    size_t copied = content.copy(textIn, len);
#endif
	if (copied != len)
    {
        delete[] textIn;
        return false;
    }
    textIn[len] = '\0';
    // call astyle
    error = false;
    char *textOut = AStyleMain(textIn, options, handleError, allocMemory);
    delete[] textIn;
    // check error
    if (error)
    {
        if (textOut)
            delete[] textOut;
        return false;
    }
    if (!textOut)
        return false;
    // return result
    std::string result(textOut, strlen(textOut));
	delete[] textOut;
    content.swap(result);
	return true;
}
Example #26
0
void Magick::Options::fileName(const std::string &fileName_)
{
  ssize_t
    max_length;

  max_length=sizeof(_imageInfo->filename)-1;
  fileName_.copy(_imageInfo->filename,max_length);
  if ((ssize_t) fileName_.length() > max_length)
    _imageInfo->filename[max_length]=0;
  else
    _imageInfo->filename[fileName_.length()]=0;
}
Example #27
0
    // distribute jobs to each CPU
    void start(crack_routine_t func) {
        uint64_t cbn = start_cbn;
        uint64_t thd_cbn = (total_cbn / thread_cnt);
        
        threads.clear();
        
        if (c!=NULL) {
          #ifdef _MSC_VER
            _aligned_free(c);
          #else
            free(c);
          #endif
          c=NULL;
        }
        thread_run = 0;
        found = false;
        
        c = (crack_opt_t*)aligned_alloc(32, thread_cnt*sizeof(crack_opt_t));

        // for each available cpu
        for (size_t i=0; i<thread_cnt; i++) {
          memset(&c[i], 0, sizeof(crack_opt_t));
          
          c[i].id = i;
          // set cracking routine
          c[i].crack = func;
          // set alphabet
          c[i].alpha_len = alphabet.length();
          alphabet.copy(c[i].alphabet, 128, 0);
          // set hash
          memcpy(c[i].hash.b, hash.b, HASH_BIN_LEN);
          // set the first combination
          c[i].start_cbn = cbn;
          c[i].pwd_len = cbn2idx(c[i].pwd_idx, cbn);
          
          // set the last combination
          if ((i+1)==thread_cnt) {
            c[i].end_cbn   = cbn + (total_cbn - (thd_cbn*i));
            c[i].total_cbn = (total_cbn - (thd_cbn*i));
          } else {
            c[i].end_cbn = (cbn + thd_cbn);
            c[i].total_cbn = (c[i].end_cbn - c[i].start_cbn);
          }
          cbn = c[i].end_cbn;
        }

        for(size_t i=0; i<thread_cnt; i++) {
          threads.push_back(std::move(std::thread(&cracker::worker, this, &c[i])));
          thread_run++;
        }
        clock_gettime(CLOCK_MONOTONIC, &ts_start);
    }
Example #28
0
   std::string StringToLowerCase(const std::string& str_string) {
      char* buf = new char[str_string.length()];
      str_string.copy(buf, str_string.length());

      for(unsigned int i = 0; i < str_string.length(); ++i)
         buf[i] = tolower(buf[i]);

      std::string r(buf, str_string.length());

      delete[] buf;

      return r;
   }
Example #29
0
 void assign(const std::string &str)
 {
     const size_t s = str.size();
     if (buffer_.size() != s)
     {
         delete[] buffer_.begin;
         buffer_.begin = new T[s];
         buffer_.end = buffer_.begin+s;
         data_.begin = buffer_.begin;
         data_.end = buffer_.end;
     }
     str.copy(data_.begin, s);
 }
Example #30
0
void feistelEncrypt( const std::string &strDesKey, const std::string &strPlain, std::string &strCipher )
{
    const int LENGTH = 8;
    
    char szDesKey[ LENGTH ];
    memset( szDesKey, 0, LENGTH );
    strDesKey.copy( szDesKey, LENGTH );
    
    char subKey[16][4];
    genSubKey( szDesKey, subKey );
    
    char plain[  LENGTH ];
    char cipher[ LENGTH ];
    strCipher.clear();
    
    int iLength = strPlain.length();
    int iLoop   = iLength / LENGTH;
    for( int i = 0; i < iLoop; i++ )
    {
        strPlain.copy( plain, LENGTH, i * LENGTH );
        feistelEncryptUnit( 16, subKey, plain, cipher );
        strCipher.append( cipher, LENGTH );
    }
    
    iLength = iLength % LENGTH;
    if( iLength == 0 )
    {
        memset( plain, LENGTH, LENGTH );
    }
    else
    {
        int iPadding = LENGTH - iLength;
        memset( plain, iPadding, LENGTH );
        strPlain.copy( plain, iLength, iLoop * LENGTH );
    }
    
    feistelEncryptUnit( 16, subKey, plain, cipher );
    strCipher.append( cipher, LENGTH );
}