Boost Spirit: Parse an int into a string. - C / C++ / MFC Discussion Boards

Re: Reading from a file in C++ Windows Application Forms

David Crow28-Feb-17 6:31

David Crow

28-Feb-17 6:31

If ReadAllText() returns a sequence, could you then call First() twice on that sequence?

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

Bitmap for dialog background questions

frqftgbdafr27-Feb-17 13:25

frqftgbdafr

27-Feb-17 13:25

I am using a bitmap for a dialog background, which works fine.
I am also doing some GDI drawing on top of the bitmap.
The problem is updating the GDI drawing causes the bitmap to blink. On a slower computer this may be a major annoyance.
The bitmap is loaded in the OnPaint() message handler, where the GDI drawing is also performed and updated.
I have tried loading the bitmap image only once, but when the GDI drawing is updated, the bitmap background is erased and not replaced.
Is it possible to load the bitmap once, and not have it erased in OnPaint() when the GDI drawing is updated?

Re: Bitmap for dialog background questions

_Flaviu27-Feb-17 20:21

_Flaviu

27-Feb-17 20:21

Have you tried to not call default OnEraseBackground ?
Something like that:

BOOL CYourDlg::OnEraseBkgnd(CDC* pDC) 
{
   return TRUE;
// return CDialog::OnEraseBkgnd(pDC);
}

Re: Bitmap for dialog background questions

frqftgbdafr28-Feb-17 2:06

frqftgbdafr

28-Feb-17 2:06

Yes, I found that in a book last night, and it works! Thank you

Ribbon UI, wrong ordering of ribbon elements ?

Maximilien27-Feb-17 8:02

Maximilien

27-Feb-17 8:02

I am trying to order a set of buttons in a ribbon bar.

The code below should create a ribbon with the layout (sorry bad paint drawing)

See expected layout : Ribbon Layout - Album on Imgur

But I get this : Ribbon Layout - Album on Imgur

Where the 3 buttons (zoom window, zoom in and zoom out) are placed on the right of the gallery.

I am not certain what I do wrong here, everything looks nicely coded !

Any insights, help, hints or tips ?

m_wndRibbonBar.Create(this);

CMFCRibbonCategory* category = m_wndRibbonBar.AddCategory(_TEXT("Test"), ITB_HOME_CATEGORY_16X16, ITB_HOME_CATEGORY_32X32 );

CMFCRibbonPanel* panel = category->AddPanel(_TEXT("Stuff"));

panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_ALL, _T("Zoom All"), 0, 0, FALSE));

panel->AddSeparator();

panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_WINDOW, _T("Zoom Window"), 1, -1, FALSE));
panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_IN, _T("Zoom In"), 26, -1, FALSE));
panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_OUT, _T("Zoom Out"), 27, -1, FALSE));

panel->AddSeparator();

CMFCRibbonGallery* viewRibbonGallery = new CMFCRibbonGallery(ID_HOME_VIEWS_RIBBON_BUTTON, _T("Views"), 7, 1, IDB_HOME_VIEWS_PALETTE_32X32, 32);
panel->Add(viewRibbonGallery);
panel->AddSeparator();

// shaded... 
CMFCRibbonButtonsGroup* viewTypeGroup = new CMFCRibbonButtonsGroup;
viewTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_MODE_NORMAL, _TEXT("Normal"), 20, FALSE));
viewTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_MODE_SHADED, _TEXT("Shaded"), 21, FALSE));
viewTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_MODE_WIREFRAME, _TEXT("Wireframe"), 22, FALSE));
panel->Add(viewTypeGroup);

CMFCRibbonButtonsGroup* wireFrameTypeGroup = new CMFCRibbonButtonsGroup;
wireFrameTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_WIREFRAME_BOUNDARY, _TEXT("Boundary"), 23, FALSE));
wireFrameTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_WIREFRAME_ISOLINE, _TEXT("Isoline"), 24, FALSE));
wireFrameTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_WIREFRAME_MESH, _TEXT("Mesh"), 25, FALSE));
panel->Add(wireFrameTypeGroup);

I'd rather be phishing!

Visual c++ android app development

Cwash26-Feb-17 23:37

Cwash

26-Feb-17 23:37

Hi everyone,
I have worked with basic knowledge of C++. I am struggling to understand how to develop an android app with the Visual C++ platform.I have installed all necessary software yet the sample codes look different from what I have learned. I really need advice, reference sheets or any related stuff that would help me on this path. Thank you.

Re: Visual c++ android app development

Richard MacCutchan27-Feb-17 0:26

Richard MacCutchan

27-Feb-17 0:26

Cwash wrote:
eference sheets or any related stuff

Google is the tool that will find such information for you.[^].

Boost Spirit: Parse an int into a string.

Maximilien21-Feb-17 2:54

Maximilien

21-Feb-17 2:54

I am trying to parse an expression like this:

F( 1, 2, 3)

and extract 1, 2 and 3 as a strings.

My test grammar and program parse properly, but the output is not "nice",

In the start, limit and increment variable contain strings like "\x1", "\x2" and "\x3"

This is part of my grammar. (the pre tag does not work "good" here)

I also tried to read the numerical value as an int and use a boost::variant to hold either an int or std:wstring, but that did not work.

Any thoughts, hints or tips ?

Thanks.

More friendly code here http://pastebin.com/2mmK9gns

struct RangeResult
{
    std::wstring start;
    std::wstring limit;
    std::wstring increment;
};

BOOST_FUSION_ADAPT_STRUCT(
    RangeGrammar::RangeResult,
    (std::wstring, start)
    (std::wstring, limit)
    (std::wstring, increment)
)

template <typename Iterator>
struct range_parser : boost::spirit::qi::grammar<Iterator, RangeResult(), iso8859_1::space_type>
{
    range_parser() : range_parser::base_type(start)
    {
            using qi::lit;
            using qi::lexeme;
            using qi::int_;
            using iso8859_1::char_;
            using iso8859_1::digit;

            variable_string %= lexeme["$(" >> +(char_ - ")") >> ")"];

            node = (int_ | variable_string);

            start %=
                lit("_RANGE")

<blockquote class="quote">
  <blockquote class="quote">
    '('
    node >> ',' >> node >> ',' >> node
    ")_"
                    ;
  </blockquote>
</blockquote>

            debug(variable_string);
            debug(start);

        }

        qi::rule<Iterator, std::wstring(), iso8859_1::space_type> variable_string;
        qi::rule<Iterator, std::wstring(), iso8859_1::space_type> node;
        qi::rule<Iterator, RangeResult(), iso8859_1::space_type> start;

};

My test program:

C++

void TestRangeGrammar()
{
    using boost::spirit::iso8859_1::space;
    typedef std::wstring::const_iterator iterator_type;
    typedef RangeGrammar::range_parser<iterator_type> range_parser;

<pre>
range_parser grammar; // Our grammar

std::array< std::wstring, 1 > testStrings =
{{
        _TEXT("_RANGE(1, 2, 3 )_")
}};

for (auto str : testStrings)

{
std::wstring::const_iterator iter = str.begin();
std::wstring::const_iterator end = str.end();

RangeGrammar::RangeResult emp;

bool r = phrase_parse(iter, end, grammar, space, emp);
if (r)
{
std::wcout << _TEXT("-------------------------\n");
std::wcout << _TEXT("Range Parsing succeeded\n");
std::wcout << _TEXT("Start: ") << emp.start << std::endl;
std::wcout << _TEXT("Start: ") << emp.limit << std::endl;
std::wcout << _TEXT("Start: ") << emp.increment << std::endl;
std::wcout << _TEXT("\n-------------------------\n");
}
else
{
std::wcout << _TEXT("-------------------------\n");
std::wcout << _TEXT("Range Parsing failed\n");
std::wcout << str << std::endl;
std::wcout << _TEXT("-------------------------\n");
}
}
}

I'd rather be phishing!

AES 128 block cipher problem running

Member 1300542516-Feb-17 19:27

Member 13005425

16-Feb-17 19:27

Hi, I'm still a beginner in coding, I need block cipher source code for my research paper where I need to get the run time for mode of operation, I already find a lot of source code but none of it seems working, example the crypto++ . I don't even know how to set it up. if anyone could help me at least on how to run the crypto++ . and fyi im using a quad core processor laptop, windows 10 and visual studio 2015. :((  :((  :((

this is the crypto++ I downloaded

Re: AES 128 block cipher problem running

CPallini16-Feb-17 20:55

CPallini

16-Feb-17 20:55

You could use Microsoft Crypto API. They provide documentation and examples: Using Cryptography (Windows)[^].

Re: AES 128 block cipher problem running

Razvan Cristian28-Feb-17 7:25

Razvan Cristian

28-Feb-17 7:25

Hi here you go:

The header file, aes.h:

C++

#ifndef AES_H
#define AES_H

#include <vector>
#include <iostream>

using namespace std;

class aes
{
public:
	aes(vector<unsigned char>& , vector<unsigned char>&, unsigned int);
	~aes();
	vector<unsigned char> encrypt();
	vector<unsigned char> dencrypt();
private:
	bool debugg = false;
	vector<unsigned char> str_key;
	vector<vector<unsigned char> > KEY;
	vector<vector<unsigned char> > KEY_SCHEDULE;
	vector<unsigned char> str_io;
	vector<vector<unsigned char> > INPUT, OUTPUT;
	unsigned int KEY_LENGHT;
	unsigned int ROUNDS;
	unsigned int GROUP_SIZE;
	unsigned int BLOCK_SIZE = 16;


	//variabile
	static const unsigned char sbox[256];
	static const unsigned char isbox[256];
	static const unsigned char srcon[256];
	static const unsigned char by_2[256];
	static const unsigned char by_3[256];
	static const unsigned char by_9[256];
	static const unsigned char by_11[256];
	static const unsigned char by_13[256];
	static const unsigned char by_14[256];

	//functii
	void getKeyFromString(vector<unsigned char>&);
	void gen_key_schedule(vector<vector<unsigned char> >&);
	vector<unsigned char> x_xor(vector<unsigned char>, vector<unsigned char>);
	vector<unsigned char> g(vector<unsigned char>&, unsigned int);
	void subytes(vector<vector<unsigned char> >&);
	void isubytes(vector<vector<unsigned char> >&);
	vector<unsigned char> subytesWord(vector<unsigned char>&);
	void debug(vector<vector<unsigned char> >&);

	void dgetInputFromString(vector<unsigned char>&);
	vector<vector<unsigned char> > beginEcryptForBlock(vector<vector<unsigned char> >&);//beginDEcryptForBlock
	vector<vector<unsigned char> > beginDEcryptForBlock(vector<vector<unsigned char> >&);
	void addRound(vector<vector<unsigned char> >&, vector<vector<unsigned char> >&);
	void getWFrmKeySched(unsigned int, vector<vector<unsigned char> >&);
	void shiftRows(vector<vector<unsigned char> >&, vector<unsigned char>&, vector<unsigned char>&, vector<unsigned char>&);
	void ishiftRows(vector<vector<unsigned char> >&, vector<unsigned char>& , vector<unsigned char>& , vector<unsigned char>& );
	void mixCol(vector<vector<unsigned char> >&);
	void imixCol(vector<vector<unsigned char> >&);
	unsigned int getNextByte(unsigned int, unsigned int);
	void populateVector4x4(vector<vector<unsigned char> >&);
};



#endif // AES_H

The cpp file , aes.cpp:

C++

#include "aes.h"
#include <vector>
#include <iostream>
#include <iomanip>

using namespace std;

const unsigned char aes::sbox[256] = {
	/* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
	/*0*/  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
	/*1*/  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
	/*2*/  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
	/*3*/  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
	/*4*/  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
	/*5*/  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
	/*6*/  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
	/*7*/  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
	/*8*/  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
	/*9*/  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
	/*a*/  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
	/*b*/  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
	/*c*/  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
	/*d*/  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
	/*e*/  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
	/*f*/  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };

const unsigned char aes::isbox[256] = {
	/* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
	/*0*/  0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
	/*1*/  0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
	/*2*/  0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
	/*3*/  0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
	/*4*/  0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
	/*5*/  0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
	/*6*/  0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
	/*7*/  0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
	/*8*/  0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
	/*9*/  0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
	/*a*/  0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
	/*b*/  0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
	/*c*/  0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
	/*d*/  0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
	/*e*/  0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
	/*f*/  0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };

const unsigned char aes::srcon[256] = {
	0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
	0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72,
	0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
	0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
	0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
	0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
	0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
	0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
	0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
	0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
	0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
	0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
	0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
	0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
	0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
	0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d };

const unsigned char aes::by_2[256] = {
	0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
	0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
	0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
	0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e,
	0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e,
	0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
	0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
	0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
	0x1b, 0x19, 0x1f, 0x1d, 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
	0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 0x23, 0x21, 0x27, 0x25,
	0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45,
	0x7b, 0x79, 0x7f, 0x7d, 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
	0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85,
	0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5,
	0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
	0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5 };

const unsigned char aes::by_3[256] = {
	0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11,
	0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21,
	0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
	0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 0x44, 0x47, 0x42, 0x41,
	0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1,
	0xf0, 0xf3, 0xf6, 0xf5, 0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1,
	0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 0xb4, 0xb7, 0xb2, 0xb1,
	0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81,
	0x9b, 0x98, 0x9d, 0x9e, 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a,
	0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 0xbf, 0xbc, 0xb9, 0xba,
	0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea,
	0xcb, 0xc8, 0xcd, 0xce, 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda,
	0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a,
	0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a,
	0x3b, 0x38, 0x3d, 0x3e, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
	0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a};

const unsigned char aes::by_9[256] = {
	0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
	0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7,
	0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
	0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 0xc7, 0xce, 0xd5, 0xdc,
	0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01,
	0xe6, 0xef, 0xf4, 0xfd, 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
	0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e, 0x21, 0x28, 0x33, 0x3a,
	0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa,
	0xec, 0xe5, 0xfe, 0xf7, 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
	0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 0x10, 0x19, 0x02, 0x0b,
	0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0,
	0x47, 0x4e, 0x55, 0x5c, 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
	0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed,
	0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d,
	0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
	0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46};

const unsigned char aes::by_11[256] = {
	0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69,
	0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9,
	0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
	0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 0xbf, 0xb4, 0xa9, 0xa2,
	0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f,
	0x46, 0x4d, 0x50, 0x5b, 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
	0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 0xf9, 0xf2, 0xef, 0xe4,
	0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54,
	0xf7, 0xfc, 0xe1, 0xea, 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
	0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 0x33, 0x38, 0x25, 0x2e,
	0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5,
	0x3c, 0x37, 0x2a, 0x21, 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
	0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68,
	0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8,
	0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
	0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3};

const unsigned char aes::by_13[256] = {
	0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b,
	0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b,
	0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
	0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 0x37, 0x3a, 0x2d, 0x20,
	0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26,
	0xbd, 0xb0, 0xa7, 0xaa, 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
	0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 0x8a, 0x87, 0x90, 0x9d,
	0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d,
	0xda, 0xd7, 0xc0, 0xcd, 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
	0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 0x56, 0x5b, 0x4c, 0x41,
	0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a,
	0xb1, 0xbc, 0xab, 0xa6, 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
	0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc,
	0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c,
	0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
	0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97};

const unsigned char aes::by_14[256] = {
	0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a,
	0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba,
	0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
	0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 0x73, 0x7d, 0x6f, 0x61,
	0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7,
	0x4d, 0x43, 0x51, 0x5f, 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
	0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 0x3e, 0x30, 0x22, 0x2c,
	0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc,
	0x41, 0x4f, 0x5d, 0x53, 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
	0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 0xe9, 0xe7, 0xf5, 0xfb,
	0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0,
	0x7a, 0x74, 0x66, 0x68, 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
	0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6,
	0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56,
	0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
	0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d};

aes::aes(vector <unsigned char>& IO, vector<unsigned char>& pass, unsigned int key_lenght)
{
	str_key = pass;
	KEY_LENGHT = key_lenght;
	getKeyFromString(str_key);
	gen_key_schedule(KEY);
	if (IO.size()<BLOCK_SIZE || IO.size() % BLOCK_SIZE != 0 )
	{
		vector<unsigned char> t(IO.size() + BLOCK_SIZE - IO.size() % BLOCK_SIZE,' ');
		str_io = t;
	}
	else
	{
		vector<unsigned char> t(IO.size());
		str_io = t;
	}
	for (unsigned int i = 0; i < IO.size(); i++)
	{
		str_io[i] = IO[i];
	}
}

vector<unsigned char> aes::encrypt()
{
	vector<unsigned char> buff(16), outCrypt(str_io.size());
	unsigned int nr = 0;
	for (unsigned int j = 0; j < str_io.size() / BLOCK_SIZE; j++)
	{
		unsigned int ii = 0;
		for (unsigned int i = j * BLOCK_SIZE; i < j * BLOCK_SIZE + BLOCK_SIZE; i++)
		{
			buff[ii] = str_io[i];
			ii++;
		}
		dgetInputFromString(buff);
		OUTPUT = beginEcryptForBlock(INPUT);
		for (int z = 0; z < 4; z++)
		{
			for (int zz = 0; zz < 4; zz++)
			{
				outCrypt[nr] = OUTPUT[z][zz];
				nr++;
			}
		}
	}

	return outCrypt;
}

vector<unsigned char> aes::dencrypt()
{
	vector<unsigned char> buff(16), outCrypt(str_io.size());
	unsigned int nr = 0;
	for (unsigned int j = 0; j < str_io.size() / BLOCK_SIZE; j++)
	{
		unsigned int ii = 0;
		for (unsigned int i = j * BLOCK_SIZE; i < j * BLOCK_SIZE + BLOCK_SIZE; i++)
		{
			buff[ii] = str_io[i];
			ii++;
		}
		dgetInputFromString(buff);
		OUTPUT = beginDEcryptForBlock(INPUT);
		for (int z = 0; z < 4; z++)
		{
			for (int zz = 0; zz < 4; zz++)
			{
				outCrypt[nr] = OUTPUT[z][zz];
				nr++;
			}
		}
	}

	return outCrypt;
}
vector<vector<unsigned char> > aes::beginEcryptForBlock(vector<vector<unsigned char> >& ynput)
{
	vector<vector<unsigned char> > temp_for_key_schedule(4, vector<unsigned char>(4));
	vector<unsigned char> temp(1, 0);
	vector<unsigned char> temp0(1, 0);
	vector<unsigned char> temp1(1, 0);

	getWFrmKeySched(0, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	for (unsigned int i = 1; i <= ROUNDS - 1; i++)
	{
		subytes(ynput);
		debug(ynput);
		shiftRows(ynput,temp,temp0,temp1);
		debug(ynput);
		//debug(ynput);
		mixCol(ynput);
		debug(ynput);
		getWFrmKeySched(i, temp_for_key_schedule);
		debug(temp_for_key_schedule);
		addRound(ynput, temp_for_key_schedule);
		debug(ynput);
	}
	subytes(ynput);
	shiftRows(ynput, temp, temp0, temp1);
	getWFrmKeySched(ROUNDS, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	return ynput;
}

vector<vector<unsigned char> > aes::beginDEcryptForBlock(vector<vector<unsigned char> >& ynput)
{
	vector<vector<unsigned char> > temp_for_key_schedule(4, vector<unsigned char>(4));
	vector<unsigned char> temp(1, 0);
	vector<unsigned char> temp0(1, 0);
	vector<unsigned char> temp1(1, 0);

	getWFrmKeySched(ROUNDS, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	ishiftRows(ynput, temp, temp0, temp1);
	isubytes(ynput);
	for (int i = ROUNDS - 1; i >= 1; i--)
	{
		getWFrmKeySched(i, temp_for_key_schedule);
		addRound(ynput, temp_for_key_schedule);
		imixCol(ynput);
		isubytes(ynput);
		ishiftRows(ynput, temp, temp0, temp1);
	}
	getWFrmKeySched(0, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	return ynput;
}
void aes::addRound(vector<vector<unsigned char> >& state, vector<vector<unsigned char> >& w)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			state[j][i] = (state[j][i] ^ w[j][i]);
		}
	}
}

void aes::shiftRows(vector<vector<unsigned char> >& ynput, vector<unsigned char>& temp, vector<unsigned char>& temp0, vector<unsigned char>& temp1)
{
    //debug(ynput);
	temp[0]=(ynput[0][1]);
	ynput[0][1] = ynput[1][1];
	ynput[1][1] = ynput[2][1];
	ynput[2][1] = ynput[3][1];
	ynput[3][1] = temp[0];

	//vector<unsigned char> temp0(1,0);
	temp[0] = ynput[0][2];
	temp0[0]=(ynput[1][2]);
	ynput[0][2] = ynput[2][2];
	ynput[1][2] = ynput[3][2];
	ynput[2][2] = temp[0];
	ynput[3][2] = temp0[0];

	//vector<unsigned char> temp1(1,0);
	temp[0] = ynput[0][3];
	temp0[0] = ynput[1][3];
	temp1[0]=(ynput[2][3]);
	ynput[0][3] = ynput[3][3];
	ynput[1][3] = temp[0];
	ynput[2][3] = temp0[0];
	ynput[3][3] = temp1[0];
	//debug(ynput);
}
void aes::ishiftRows(vector<vector<unsigned char> >& ynput, vector<unsigned char>& temp, vector<unsigned char>& temp0, vector<unsigned char>& temp1)
{
	//vector<unsigned char> temp(1,0);
	temp[0] = (ynput[3][1]);
	ynput[3][1] = ynput[2][1];
	ynput[2][1] = ynput[1][1];
	ynput[1][1] = ynput[0][1];
	ynput[0][1] = temp[0];

	//vector<unsigned char> temp0(1,0);
	temp[0] = ynput[3][2];
	temp0[0] = (ynput[2][2]);
	ynput[3][2] = ynput[1][2];
	ynput[2][2] = ynput[0][2];
	ynput[1][2] = temp[0];
	ynput[0][2] = temp0[0];

	//vector<unsigned char> temp1(1,0);
	temp[0] = ynput[3][3];
	temp0[0] = ynput[2][3];
	temp1[0] = ynput[1][3];
	ynput[3][3] = ynput[0][3];
	ynput[2][3] = temp[0];
	ynput[1][3] = temp0[0];
	ynput[0][3] = temp1[0];
}
void aes::mixCol(vector<vector<unsigned char> >& ynput)
{
	//vector<vector<unsigned char> > buff;
	//vector<vector<unsigned char> > buff(4, vector<unsigned char>(4));
	//populateVector4x4(buff);
	unsigned char buff[4][4];
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			buff[i][j] = (by_2[(int)ynput[i][j]] ^ by_3[(int)ynput[i][getNextByte(3, j + 1)]] ^ ynput[i][getNextByte(3, j + 2)] ^ ynput[i][getNextByte(3, j + 3)]);
		}
	}
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			ynput[j][i] = buff[j][i];
		}
	}
}

void aes::imixCol(vector<vector<unsigned char> >& ynput)
{
	//vector<vector<unsigned char> > buff;
	//populateVector4x4(buff);
	//vector<vector<unsigned char> > buff(4, vector<unsigned char>(4));
	unsigned char buff[4][4];
	for (unsigned int i = 0; i < 4; i++)
	{
		for (unsigned int j = 0; j < 4; j++)
		{
			buff[i][j] = by_14[ynput[i][j]] ^ by_11[ynput[i][getNextByte(3, j + 1)]] ^ by_13[ynput[i][getNextByte(3, j + 2)]] ^ by_9[ynput[i][getNextByte(3, j + 3)]];
		}
	}
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			ynput[j][i] = buff[j][i];
		}
	}
}
void aes::getWFrmKeySched(unsigned int pas, vector<vector<unsigned char> >& temp_for_key_schedule)
{
	//vector<vector<unsigned char> > temp;
	//populateVector4x4(temp);
	//vector<vector<unsigned char> > temp_for_key_schedule(4, vector<unsigned char>(4));

	unsigned int nr = 0;
	for (unsigned int i = 4 * pas; i < (pas + 1) * 4; i++)//la fel 4==word_size oricum ar fi
	{
		for (unsigned int j = 0; j < 4; j++)
		{
			temp_for_key_schedule[nr][j] = KEY_SCHEDULE[i][j];
		}
		nr++;
	}
}
void aes::dgetInputFromString(vector<unsigned char>& str)
{
	unsigned int nr = 0;
	//populateVector4x4(INPUT);
	vector<vector<unsigned char> > t(4, vector<unsigned char>(4));
	INPUT = t;
	for (unsigned int i = 0; i < 4; i++)
	{
		for (unsigned int j = 0; j < 4; j++)
		{

			INPUT[i][j] = str[nr];
			nr++;
		}
	}
}
void aes::getKeyFromString(vector<unsigned char>& str_key)
{
	switch (KEY_LENGHT)
	{
	case 16:
		ROUNDS = 10;
		//KEY =  [4,4];
		KEY = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };
		GROUP_SIZE = 4;
		break;
	case 24:
		ROUNDS = 12;
		KEY = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };
		GROUP_SIZE = 6;
	case 32:
		ROUNDS = 14;
		KEY = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };
		GROUP_SIZE = 8;
	default:
		break;
	}
	for (unsigned int i = 0; i < (ROUNDS +1)*4; i++)
	{
		vector<unsigned char> temp = { 0, 0, 0, 0 };
		KEY_SCHEDULE.push_back(temp);
	}
	int nr = 0;
	for (unsigned int i = 0; i < GROUP_SIZE; i++)
	{
		for (unsigned int j = 0; j < 4; j++)
		{
			KEY[i][j] = str_key[nr];
			nr++;
		}
	}
	//debug(KEY);
}
void aes::gen_key_schedule(vector<vector<unsigned char> >& KEY)
{
	for (unsigned int i = 0; i < GROUP_SIZE; i++)
	{
			KEY_SCHEDULE[i] = KEY[i];
	}
	for (unsigned int i = GROUP_SIZE; i < (ROUNDS + 1) * 4; i = i + GROUP_SIZE)
	{
		KEY_SCHEDULE[i] = x_xor(KEY_SCHEDULE[i - GROUP_SIZE], g(KEY_SCHEDULE[i - 1], (int)(i / GROUP_SIZE)));
		for (unsigned int ii = 1; ii < GROUP_SIZE; ii++)
		{
		     if ((i + ii) == 60) { break; }
                    if ((i + ii) % 8 == 4)
                    {
                        KEY_SCHEDULE[i + ii] = x_xor(subytesWord(KEY_SCHEDULE[i + ii - 1]), KEY_SCHEDULE[i + ii - GROUP_SIZE]);
                    }
                     else
                    {
                        KEY_SCHEDULE[i + ii] = x_xor(KEY_SCHEDULE[i + ii - 1], KEY_SCHEDULE[i + ii - GROUP_SIZE]);
                    }

		}
	}

	//debug
	if (debugg)
	{
		for (unsigned int i = 0; i < (ROUNDS + 1) * 4 ; i = i +GROUP_SIZE)
			{
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][0] << endl;
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][1] << endl;
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][2] << endl;
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][3] << endl;
				if (KEY_LENGHT >= 32)
				{
					if (i == 56) { break; }
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][0] << endl;
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][1] << endl;
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][2] << endl;
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][3] << endl;
				}
				cout << endl;
			}
	}

}

vector<unsigned char> aes::x_xor(vector<unsigned char> a , vector<unsigned char> b)
{
	if (a.size()==b.size())
	{
		vector<unsigned char> return_vector;
		for (unsigned int i = 0; i < a.size(); i++)
		{
			return_vector.push_back(a[i] ^ b[i]);
		}
		return return_vector;
	}
	else
	{
		cout << "the words are not the same lenght!!!" << endl;
		return { 0 };
	}
}
vector<unsigned char> aes::g(vector<unsigned char>& arr, unsigned int pas)
{
	//rotatie la stanga a unui vector liniar 
        // roation to the left of a vector
	vector<unsigned char> temp_vect(4, 0);
	temp_vect[0] = arr[1];
	temp_vect[1] = arr[2];
	temp_vect[2] = arr[3];
	temp_vect[3] = arr[0];

	//substitutie
	for (unsigned int i = 0; i < 4; i++)
	{
		temp_vect[i] = sbox[(unsigned int)temp_vect[i]];
	}
	vector<unsigned char> rcon_temp;
	rcon_temp.push_back(srcon[pas]);
	for (unsigned int i = 0; i < 3; i++)
	{
		rcon_temp.push_back(0x00);
	}

	return x_xor(temp_vect, rcon_temp);
}

void aes::subytes(vector<vector<unsigned char> >& arr)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			arr[j][i] = sbox[(unsigned int)arr[j][i]];
		}
	}
}

void aes::isubytes(vector<vector<unsigned char> >& arr)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			arr[j][i] = isbox[(unsigned int)arr[j][i]];
		}
	}
}
vector<unsigned char> aes::subytesWord(vector<unsigned char>& vect)
{
	vector<unsigned char> buffer;
	for (unsigned int i = 0;  i < 4;  i++)
	{
		buffer.push_back(sbox[(unsigned int)vect[i]]);
	}
	return buffer;
}

unsigned int aes::getNextByte(unsigned int maxIDFrom0, unsigned int x)
{
	if (x > maxIDFrom0)
	{
		x = x - maxIDFrom0;
		return x - 1;
	}
	else
	{
		return x;
	}
}

void aes::populateVector4x4(vector<vector<unsigned char> >& vec)
{

	//A(dimension, vector<int>(dimension))
	vector<vector<unsigned char> > vec_temp(4,vector<unsigned char>(4));
	vec = vec_temp;

}

void aes::debug(vector<vector<unsigned char> >& arr)
{
	if (debugg)
	{
		for (unsigned int i = 0; i < arr.size(); i++)
		{
			cout << hex << setw(2) << setfill('0') << +arr[0][i] << " " << hex << setw(2) << setfill('0') << +arr[1][i] << " " << hex << setw(2) << setfill('0') << +arr[2][i] << " " << hex << setw(2) << setfill('0') << +arr[3][i] << endl;
		}
		cout << endl;
	}

}
aes::~aes(){}

Books on learning wxWidgets and understanding terminology?

Member 1297423513-Feb-17 11:34

Member 12974235

13-Feb-17 11:34

If I do some C++ programming and I get to the point where I wish to make some graphical programs, I'm kind of leaning in the direction of using wxWidgets. Was wondering though if there are some books out there that explain things.

I hate to look at code and not know what this word means or this symbol.

For example if I see that something reads:

wxFrame* window = new wxFrame(NULL, -1)

I can't stand not knowing what each part of that means.

So my question is are there any books that do a good job of explaining things like that which I will undoubtedly run into?

I do recognize some of that since I've done some Java which always uses classes so.

Re: Books on learning wxWidgets and understanding terminology?

VISWESWARAN199813-Feb-17 19:34

VISWESWARAN1998

13-Feb-17 19:34

This will help you to get started,

wxWidgets tutorial[^]

and for the quick help on things you may post the question here

wxWidgets Discussion Forum - Index page[^]

This is an active forum like CodeProject but especially for wxwidgets and if you have any doubts regarding wxWidgets you can post your question there and you may get a response quickly. I tried.

ASSERT(pState->m_hSocketWindow != NULL); When trying to close in the same thread Socket Was Created

ForNow12-Feb-17 16:02

ForNow

12-Feb-17 16:02

Hi
I have CAsyncScoket Class In CwinThread (UI)

I know all the notification are done in the Context Of the MainThread

When I do get notification from lets say a OnSend I have the Threadid in the CAsynSocket

class and Do A PostThreadMessage to the thread to do the send

However I am trying to Close the Scoket in the same thread I created it

All the while whether in the main thread or CwinThread the m_hSocket value is the same

Re: ASSERT(pState->m_hSocketWindow != NULL); When trying to close in the same thread Socket Was Created

Jochen Arndt13-Feb-17 1:19

Jochen Arndt

13-Feb-17 1:19

Without seeing your code this can't be answered.

But some possible reasons are:

The socket has been closed already
The function is called from another thread
The socket has been detached
You have a statically linked MFC application, created the socket in a secondary thread, and did not call AfxSocketInit in that thread

I don't quite get this thing I've noticed

Member 1297423512-Feb-17 15:56

Member 12974235

12-Feb-17 15:56

If you just got done writing some C++ code and naturally you want to save the file, you tell Windows where you want to save it and then you will see in the bottom field the Save as Type question. If you choose .cpp, and just do that alone the file will not be saved as a C++ source file.

I don't get it.

Seems to me if you tell it that you want to save it as a .cpp source file then all you should have to do is just figure out what you want to name your file and that's all.

But you actually have to give the file the .cpp extension yourself.

You can't just do this: My Program

You have to do this: My Program.cpp

Why?

Re: I don't quite get this thing I've noticed

David Crow12-Feb-17 16:31

David Crow

12-Feb-17 16:31

Member 12974235 wrote:
...the file will not be saved as a C++ source file.

What will it be saved as?

Member 12974235 wrote:
You can't just do this: My Program

What happens if you do?

What editor are you using?

modified 13-Feb-17 8:32am.

Re: I don't quite get this thing I've noticed

Richard MacCutchan12-Feb-17 23:20

Richard MacCutchan

12-Feb-17 23:20

That is correct, Windows cannot guess what type your file is.

Re: I don't quite get this thing I've noticed

Member 1297423513-Feb-17 11:28

Member 12974235

13-Feb-17 11:28

Well if the drop down box says Save as .cpp file, Windows does not have to guess. It should be saved as a .cpp file. Otherwise we have a wasted box with useless info in it.

Re: I don't quite get this thing I've noticed

Richard MacCutchan13-Feb-17 21:49

Richard MacCutchan

13-Feb-17 21:49

I guess you think there is something special about a .cpp file. It is just a text file that (may) happen to contain C++ source code. But that means nothing to Windows, it is just a convenience for us humans.

Re: I don't quite get this thing I've noticed

leon de boer15-Feb-17 17:31

leon de boer

15-Feb-17 17:31

The file type recognition is controlled by windows and windows by default doesn't know what a .CPP is or many other types for that matter. More distinctly it doesn't know what program to associate to the file type. That is all done via the File Type Association widget in control panel in windows. The save file dialog is a common control dialog from windows and it is it that is directing the prompt.

Usually any good installer for a C++ program makes the changes for association to the file type for you. So either you have a lazy installer for a C++ program or it made the association and you have since broken it.

Whatever the case stop complaining about it and go fix it in the File Type Association widget in the windows control panel. If you need assistance an internet search on "File type association on Windows" should give you a multitude of links to work with. It's a bit like complaining when you click on a .BMP file it doesn't open it in the right editor, yeah so go fix it.

As an extra helpful tip I can tell you that on the file type association it is useful to select plain text filter onto the .CPP file type. That allows windows searches to go inside your .CPP files on a text search. It is sometimes useful if you have a lot of code directories (like I do) to find a specific block of code if you know something unique about it. You can do a computer wide search for the text string in a .CPP file and it has saved me hours of searching.

In vino veritas

modified 15-Feb-17 23:41pm.

UDP Server vs Client

bkelly1311-Feb-17 13:40

bkelly13

11-Feb-17 13:40

Please direct me to an article that discusses the difference between a UDP Server application and the Client application.

So far I surmise that the server starts with no knowledge of where a client might be. It can either begin broadcasting data (this is my current need) or listen for a client to connect.

On the other hand, the client must know the address of the server and it either begins listening for broadcasts from the server or it sends a message to the server to accomplish something, such as to solicit some information from the server.

Thank you for your time

Re: UDP Server vs Client

Richard MacCutchan11-Feb-17 20:40

Richard MacCutchan

11-Feb-17 20:40

Google for "sockets udp" and you will find plenty. Be aware that if you use UDP then you need to implement your own protocol for checking that all messages get processed, and in the correct order.

Re: UDP Server vs Client

bkelly1312-Feb-17 3:38

bkelly13

12-Feb-17 3:38

I have done that. Here is the first page of results from my good search for “udp sockets”

Before providing the list, I do suspect that if I already knew the differences I may well find that information in these sites. As I do not, that information can be rather difficult to pick out.

https://www.cs.rutgers.edu/~pxk/417/notes/sockets/udp.html
goes right to code, does not discuss the difference
http://www.cs.dartmouth.edu/~campbell/cs60/socketprogramming.html
does not discuss why there is client and server with UDP
https://en.wikipedia.org/wiki/Network_socket
does not discuss
https://www.w3.org/TR/tcp-udp-sockets/
Section 9 begins UDP, jumps right into code with no explanation
Just for the record, this is the most thorough discussion I have found
http://www.binarytides.com/programming-udp-sockets-c-linux/
does not discuss the differences
https://www.abc.se/~m6695/udp.html
does not discuss
https://developer.chrome.com/apps/sockets_udp
does not discuss
https://cs.nyu.edu/~bacon/phd-thesis/diss/node32.html
does not discuss the differences
https://wiki.python.org/moin/UdpCommunication
“server” is in the article in only one place discussing a Windows bug
http://www.microhowto.info/howto/listen_for_and_receive_udp_datagrams_in_c.html
Starts off with:
Suppose that you wish to write a server that implements the …
But does not address the differences.
References RFC 867 which does not discuss the differences

Do I need to continue?
I am looking for a discussion on the differences between server and client in UDP operations. Not in the code difference but in the difference in concept between the two. Looks to me like two servers or two clients can well carry on a conversation via UDP packets.

Thank you for your time

Re: UDP Server vs Client

Richard MacCutchan12-Feb-17 6:07

Richard MacCutchan

12-Feb-17 6:07

There is no big difference, apart from the fact that the server is (usually) passive and the clients active. I'm not really sure what your real issue is, since this is not anything specific to UDP.

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.