เชนเซเช เชเซเช เชนเชฐเชเชค เชตเชฟเชจเชพ เชถเชฐเซ เชเชฐเซเชถ, เชเชเชตเชพเชฐ เชฎเชจเซ เชธเชพเชเซเชทเชพเชคเซเชเชพเชฐ เชฅเชฏเซ (เชธเชพเชฐเซ เชฐเซเชคเซ, เชเซเชฌ เชถเชเซเชคเชฟเชถเชพเชณเซ เชจเชฅเซ, เชชเซเชฐเชฎเชพเชฃเชฟเชเชชเชฃเซ) เช เชจเซ เชเช เชชเซเชฐเซเชเซเชฐเชพเชฎ เชชเซเชฐเชฟเชจเซเช เชเชฐเชตเชพเชจเซ เชตเชฟเชเชพเชฐ เชเชตเซเชฏเซ เชเซ เชเซเชฒเชพเชฏเชเชเชฎเชพเชเชฅเซ เชธเชฐเซเชตเชฐ เชชเชฐ เชเชฌเซ เชธเซเชฅเชพเชจเชพเชเชคเชฐเชฟเชค เชเชฐเซ เชเซ. เชชเชฐเซเชฏเชพเชชเซเชค เชธเชฐเชณ เช เชงเชฟเชเชพเชฐ? เชธเชพเชฐเซเช, เช เชจเซเชญเชตเซ เชชเซเชฐเซเชเซเชฐเชพเชฎเชฐ เชฎเชพเชเซ, เชคเซ เชเชตเซเช เชนเชถเซ. เชถเชฐเชคเซ เชธเชฐเชณ เชเซ - เชคเซเชคเซเชฏ-เชชเชเซเชท เชชเซเชธเซเชคเชเชพเชฒเชฏเซเชจเซ เชเชชเชฏเซเช เชเชฐเชถเซ เชจเชนเซเช. เชธเซเชฆเซเชงเชพเชเชคเชฟเช เชฐเซเชคเซ, เชคเซ เชฅเซเชกเซเช เชตเชงเซ เชเชเชฟเชฒ เชเซ, เชชเชฐเชเชคเซ เชเชชเซเชฒ เชเซ เชเซ เชคเชฎเชพเชฐเซ เชคเซเชจเซ เชถเซเชงเซ เชเชพเชขเชตเซเช โโเชชเชกเชถเซ เช เชจเซ เชเชฆเชพเชนเชฐเชฃเซ เชถเซเชงเชตเชพ เชชเชกเชถเซ, เชธเชพเชฐเซเช, เชเชตเชพ เชตเซเชฏเชตเชธเชพเชฏ. เชฎเซเช เชจเชเซเชเซ เชเชฐเซเชฏเซเช เชเซ เช เชเชพเชฐเซเชฏ เชฎเชพเชฐเชพ เชชเชฐ เชเซ. เชเชชเชฐเชพเชเชค, เชคเซ เชเชเซเชเชจเซเชฏ เชเซ เชเซ เชคเซเชฏเชพเช เชชเชฐเซเชฏเชพเชชเซเชค เชเซเชก เชนเซเชฏ เชเซเชฅเซ เชคเชฎเชจเซ เชฎเชฆเชฆเชจเซ เชเชฐเซเชฐ เชนเซเชฏ เชคเซ เชคเซเชจเซ เชซเซเชฐเชฎ เชชเชฐ เชชเซเชธเซเช เชเชฐเซ เชถเชเชพเชฏ. เชธเซ เชชเซเชฐเชฅเชฎ, เชฎเชพเชฐเซ เชจเชเชฐ FTP เชชเชฐ เชชเชกเซ, เชฎเชพเชฐเซเช เชฆเซเชตเชพเชฐเชพ, OS เชเซเชฎเชพเช Windows เชตเชฟเชเชธเชพเชตเชตเชพเชฎเชพเช เชเชตเซ เชฐเชนเซเชฏเซเช เชเซ. FTP เชจเซ เชซเชพเชฏเชฆเซ เช เชเซ เชเซ เชคเชฎเซ เชฎเชพเชคเซเชฐ เชเช เชเชฎเซเช เช เชจเชนเซเช, เชชเชฐเชเชคเซ เชคเซเชจเชพ เชฆเซเชตเชพเชฐเชพ เชเซเชเชชเชฃ เชซเชพเชเชฒ เชเซเชฐเชพเชจเซเชธเชซเชฐ เชเชฐเซ เชถเชเซ เชเซ. เชซเชพเชเชฒเชเชฟเชฒเชพ เชธเชฐเซเชตเชฐ เชกเชพเชเชจเชฒเซเชก เชเชฐเซเชฏเชพ เชชเชเซ, เชตเชพเชเชเชตเชพ / เชฒเชเชตเชพ เช เชจเซ เชชเชพเชธเชตเชฐเซเชก เชธเชพเชฅเซ เชตเชชเชฐเชพเชถเชเชฐเซเชคเชพ เชฌเชจเชพเชตเชตเชพ เชฎเชพเชเซ เชเช เชกเชฟเชฐเซเชเซเชเชฐเซ เชถเซเชฐ เชเชฐเซเชฏเชพ เชชเชเซ, เชฎเซเช เชซเชพเชเชฒเชเชฟเชฒเชพ เชเซเชฒเชพเชฏเชเชเชจเซ เชเชจเซเชเซเช เชเชฐเชตเชพเชจเซ เชชเซเชฐเชฏเชพเชธ เชเชฐเซเชฏเซ, เชฌเชงเซเช เชเชพเชฎ เชเชฐเซเชฏเซเช. เชฎเซเช C/C++ เชฎเชพเช เชเช เชธเชฐเชณ เชเซเชก เชเชฆเชพเชนเชฐเชฃ เชฌเชจเชพเชตเซเชฏเซเช:
#include <iostream>
void main()
{
FILE* fs;
fopen_s(&fs, "1.txt", "w");
if (fs)
{
fwrite("userrnpasswordrnsend D:\share.txtrnbye", 1, sizeof("userrnpasswordrnsend D:\share.txtrnbye"), fs);
fwrite("00", 1, sizeof("00"), fs);
fclose(fs);
}
system("ftp -s:1.txt 127.0.0.1");
}
เชเซ เชฎเชพเชฐเซ เชฎเซเชฎเชฐเซ เชฎเชจเซ เชธเซเชตเชพ เชเชชเซ เชเซ, เชคเซ เชชเชเซ เชฌเชงเซเช เชฒเซเชเชฒเชนเซเชธเซเช เชชเชฐ เชเชพเชฎ เชเชฐเซ เชเซ, เช เชจเซ เชจเซเชเชตเชฐเซเช เชชเชฐ เชเซเชฐเชพเชจเซเชธเชฎเชฟเช เชเชฐเชคเซ เชตเชเชคเซ, เชฎเซเชเชฒเชตเชพเชจเซ เชฒเชพเชเชจเชฎเชพเช เชญเซเชฒ เชเชตเซ. เช เชนเซเช เชถเซเช เช เชจเซเชเซเชณ เชเซ? เชคเซเชฎ เชเชคเชพเช เชฎเชพเชฐเชพ เชฎเชคเซ เชคเซ เชชเซเชฐเซเชเซเชฐเชพเชฎเซเชธ เช เชจเซ เชเชเชเซ เชฆเซเชตเชพเชฐเชพ เชธเชเซเชฐเชฟเชฏ เชฅเชตเซเช เชเชตเชถเซเชฏเช เชเซ. เชเซ เชคเชฎเซ เช เชชเชฆเซเชงเชคเชฟเชจเซ เชธเชฎเชธเซเชฏเชพ เชถเซเช เชเซ เชคเซ เชถเซเชงเซ เชเชพเชขเซ เช เชจเซ เชเชฟเชชเซเชชเชฃเซเชเชฎเชพเช เชฒเชเซ, เชคเซ เชคเซ เชธเชฐเชธ เชฐเชนเซเชถเซ.
เชซเซเชฐเชฎเชจเชพ เชธเชฎเซเชน เชชเชฐ เชเชตเชพเชฌ เชจ เชฎเชณเชคเชพเช, เชฎเซเช เช เชเซเชก เชเซเชกเซ เชฆเซเชงเซ เช เชจเซ เชธเซเชเซเช เชจเซเชเชตเชฐเซเชเซเชธ เชฎเชพเชเซ เชเชจเซเชเชฐเชซเซเชธเชจเซ เชเชชเชฏเซเช เชเชฐเชตเชพเชจเซเช เชจเชเซเชเซ เชเชฐเซเชฏเซเช. เชฎเชจเซ เชชเชนเซเชฒเชพเชฅเซ เช เช เชจเซเชฏ เชชเซเชฐเซเชเซเชฐเชพเชฎเชฎเชพเช เช เชเซเชทเชฐเซเชจเซ เชถเซเชฐเซเชฃเซ เชชเชธเชพเชฐ เชเชฐเชตเชพเชจเซ เช เชจเซเชญเชต เชนเชคเซ. เชฎเชพเชฐเซเช เชฆเซเชตเชพเชฐเชพ, เชคเชฎเซ เชเซเชฐเชพเชจเซเชธเชชเซเชฐเซเช เชฒเซเชฏเชฐ เชตเชฟเชถเซเชจเชพ เชชเซเชฐเชเชฐเชฃเชฎเชพเช เชเซเชจเซเชจเชฌเซเชฎ, เชเชฎเซเชชเซเชฏเซเชเชฐ เชจเซเชเชตเชฐเซเชเซเชธเชฎเชพเชเชฅเซ เชตเชพเชเชเซ เชถเชเซ เชเซ. เชเซเชฒเชพเชฏเชเช เช เชจเซ เชธเชฐเซเชตเชฐเชจเซเช เชเชฆเชพเชนเชฐเชฃ เชเซ, เชเซ เชเซ "เชเชฃเชพ เชเซเชฒเชพเชฏเชเช - เชเช เชธเชฐเซเชตเชฐ" เชเชจเซเชเซเชถเชจ เชฎเชพเชเซ เชจเชนเซเช, เชชเชฐเชเชคเซ เชซเชเซเชค "เชเช เชเซเชฒเชพเชฏเชเช - เชเช เชธเชฐเซเชตเชฐ" เชฎเชพเชเซ. เชเซเชฐเชพเชจเซเชธเชฎเชฟเชถเชจ เชเชจเซเชเชฐเชจเซเช เชชเชฐ เชนเซเชตเชพเชฅเซ, เชคเชฎเชพเชฐเซ เชกเซเชเชพเชจเซ เชเซเชเช เชฐเซเชคเซ เชเชจเซเชเซเชฐเชฟเชชเซเช เชเชฐเชตเชพเชจเซ เชเชฐเซเชฐ เชเซ. เช เชฎเชพเชเซ, เชฌเซเชฒเซเช เชธเชพเชเชซเชฐเชจเซ เชเชชเชฏเซเช เชฅเชพเชฏ เชเซ - เชซเซเชธเซเชเซเชฒ เชจเซเชเชตเชฐเซเช. เชชเซเชฒเชธ เชธเชฐเซเชตเชฐ เชชเชฐ เชเชฃเชพ (เชเช เชเชฐเชคเชพเช เชตเชงเซ เชเซเชฒเชพเชฏเชเช) เชเซเชฒเชพเชฏเชเช เชฌเชจเชพเชตเชตเชพ เชเชฐเซเชฐเซ เชเซ. เช เชเชฐเชตเชพ เชฎเชพเชเซ, เช เชฎเซ เชฅเซเชฐเซเชกเซเชธเชจเซ เชเชชเชฏเซเช เชเชฐเซเชถเซเช, เชเซเชฐเชพเชจเซเชธเชฎเชฟเชถเชจ เชฎเชพเชเซเชจเซ เชเชฌเซ เชเซเชฒเชพเชฏเชเชเชฎเชพเชเชฅเซ เชธเซเชเซเชฐเซเชจเชจเซ เชธเซเชเซเชฐเซเชจเชถเซเช เชฒเซเชถเซ, เชเชจเชเซเชฐเชฟเชชเซเช เชฅเชถเซ เช เชจเซ เชธเชฐเซเชตเชฐ เชชเชฐ เชเซเชฐเชพเชจเซเชธเชฎเชฟเช เชฅเชถเซ, เชเซเชฏเชพเช เชคเซเชจเซ เชกเชฟเชเซเชฐเชฟเชชเซเช เชเชฐเชตเชพเชฎเชพเช เชเชตเชถเซ เช เชจเซ เชคเชฐเชค เช เชเซเชฒเชตเชพ เชฎเชพเชเซเชจเชพ เชกเชฟเชซเซเชฒเซเช เชชเซเชฐเซเชเซเชฐเชพเชฎ เชฆเซเชตเชพเชฐเชพ เชธเซเชเซเชฐเซเชจ เชชเชฐ เชชเซเชฐเชฆเชฐเซเชถเชฟเชค เชเชฐเชตเชพเชฎเชพเช เชเชตเชถเซ * .tga เชเชฌเซเช.
เชธเชฐเซเชตเชฐ เชเซเชก:
#include <iostream>
#include <WinSock.h>
#pragma comment (lib,"WS2_32.lib")
#include <fstream>
#include <algorithm>
#include <string>
#include <iterator>
#include <vector>
void error(const char* msg)
{
//perror(msg);
std::cout<<'n'<<WSAGetLastError();
WSACleanup();
std::cin.ignore();
exit(1);
}
void bzero(char*buf, int l)
{
for (int i = 0; i < l; i++)
buf[i] = '';
}
struct arg_s
{
unsigned char* buffer2;
bool exit;
};
char** buffer;
struct arg_sa
{
struct arg_s* lalk;
int current;
};
#define type struct arg_sa
int sockfd, * newsockfd;//ัะปััะฐััะธะน ะธ ะผะฐััะธะฒ ะบะปะธะตะฝััะบะธั
ัะพะบะตัะพะฒ
int buflen2 = 10292000;//ะผะฐะบัะธะผะฐะปัะฝัะน ัะฐะทะผะตั ะธะทะพะฑัะฐะถะตะฝะธั ะฒ ะฑะฐะนัะฐั
ะดะปั RGBA*Width*Height
struct sockaddr_in *cli_addr;
int* clilen;
int currentclient,cc;//ัั-ะบะปะธะตะฝั ะฟะพ ััะตัั(ะดะปั ะทะฐะฟะธัะธ ะธะฝะบัะตะผะตะฝัะฐ ะธะผะตะฝะธ ัะฐะนะปะฐ ะบะปะธะตะฝัะฐ ะธะทะพะฑัะฐะถะตะฝะธั)
typedef unsigned long long uint64_t;
typedef unsigned int uint32_t;
#define N 8//ัะฐะทะผะตั ะฑะปะพะบะฐ
#define F32 0xFFFFFFFF
uint32_t RK[N];//ัะฐัะฝะดะพะฒัะต ะบะปััะธ
#define size64 sizeof(uint64_t)
#define ROR(x,n,xsize)((x>>n)|(x<<(xsize-n)))
#define ROL(x,n,xsize)((x<<n)|(x>>(xsize-n)))
#define RKEY(r)((ROR(K,r*3,size64*8))&F32)
const uint64_t K = 0x96EA704CFB1CF671;//ะบะปัั ัะธััะพะฒะฐะฝะธั
struct hostent* server;
uint32_t F(uint32_t subblk, uint32_t key)
{
return subblk + key;//ััะฝะบัะธั ัะธััะพะฒะฐะฝะธั
}
void createRoundKeys()
{
for (int i = 0; i < N; i++)
RK[i] = (ROR(K, i * 8, size64 * 8)) & F32;
}
uint64_t decrypt(uint64_t c_block)//ัะฐััะธััะพะฒะบะฐ ะฑะปะพะบะพะฒ ัะตััั ัะตะนััะตะปั
{
//select subblocks
uint32_t left = (c_block >> 32) & F32;
uint32_t right = c_block & F32;
uint32_t left_, right_;//subblock in the end of round
for (int r = N - 1; r >= 0; r--)
{
uint32_t fk = F(left, RK[r]);
left_ = left;
right_ = right ^ fk;
if (r > 0)//swap places to next round
{
left = right_;
right = left_;
}
else //last round not swap
{
left = left_;
right = right_;
}
}
//collect subblock in block
uint64_t block = left;
block = (block << 32) | (right & F32);
return block;
}
void session_(LPVOID args)//ััะฝะบัะธั ะฟะพัะพะบะฐ ะปั ะบะฐะถะดะพะณะพ ะบะปะธะตะฝัะฐ
{
int current = currentclient++;
bzero((char*)&(cli_addr[current]), sizeof(&(cli_addr[current])));
newsockfd[current] = accept(sockfd, (struct sockaddr*)&(cli_addr[current]), &(clilen[current]));
if (newsockfd[current] < 0)
{
error("Error on acceptn");
}
char* s = new char[100];
int n = recv(newsockfd[current], s, 100, 0);
int buflen2 = atoi(s);//ะฟะพะปััะฐะตะผ ัะธัะปะพ ะฑะฐะนัะพะฒ ะธะทะพะฑัะฐะถะตะฝะธั
FILE* f;
std::string name = "Screen";
cc++;
_itoa_s(cc, s, 100, 10);
name += s;
name += ".tga";
fopen_s(&f,name.c_str(), "wb");//ัะพะทะดะฐะตะผ ัะฐะนะป ะธะทะพะฑัะฐะถะตะฝะธั ั ัะฒะตะปะธัะธะฒะฐะตัะธะผัั ะฝะฐ 1 ะธะผะตะฝะตะผ, ััะพะฑั ะฝะต ะฟะตัะตะทะฐะฟะธัะฐัั
if (f != NULL)
{
unsigned char tgaHeader[12] = { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
unsigned char header[6];
n = recv(newsockfd[current], buffer[current], sizeof(tgaHeader), 0);
fwrite((unsigned char*)buffer[current], 1, sizeof(tgaHeader), f);
bzero(buffer[current], buflen2);
n = recv(newsockfd[current], buffer[current],sizeof(header), 0);
fwrite((unsigned char*)buffer[current], 1, sizeof(header), f);//ะทะฐะฟะธัะฐะปะธ ั
ะธะดะตัั
bzero(buffer[current], buflen2);
n = recv(newsockfd[current], buffer[current], buflen2, 0);//ะฟะพะปััะธะปะธ ะฑะฐะนัั ัะฐะผะพะณะพ ะธะทะพะฑัะฐะถะตะฝะธั
//
//ัะฐััะธััะพะฒะบะฐ ะฑะฐะนัะพะฒ
createRoundKeys();
unsigned long long id;
std::vector<uint64_t>* plaintext = new std::vector<uint64_t>();
int i = 0;
while (i<buflen2)
{
memcpy(&id, (buffer[current]) + i, N);
plaintext->push_back(decrypt(id));
i += 8;
}
std::cout << "i=" << i << std::endl;
i = 0;
char str_[N + 1];
memset(str_, 0, N);
str_[N] = '';
for (std::vector<uint64_t>::iterator it = plaintext->begin(); it != plaintext->end(); ++it)
{
memcpy(str_, &*it, N);
fwrite((unsigned char*)str_, sizeof(unsigned char), N/*strlen(str_)*/, f);
i += 8;
}
std::cout << "i=" << i << std::endl;
//ะบะพะฝะตั ัะฐัะธััะพะฒะบะธ ะฑะฐะนัะพะฒ
//fwrite((unsigned char*)buffer[current], sizeof(char), buflen2, f);
fclose(f);
}
system(name.c_str());//ะพัะบััะฒะฐะตะผ ะธะทะพะฑัะฐะถะตะฝะธะต *.tga ะฒัััะพะตะฝะฝัะผ ัะตะดะฐะบัะพัะพะผ
}
int main()
{
cc = 0;
WSADATA ws = { 0 };
if (WSAStartup(MAKEWORD(2, 2), &ws) == 0)
{
currentclient = 0;
int maxclients = 2;//ะผะฐะบัะธะผะฐะปัะฝะพะต ัะธัะปะพ ะบะปะธะตะฝัะพะฒ
cli_addr = new struct sockaddr_in[maxclients];
clilen = new int[maxclients];
buffer = new char* [maxclients];
for (int i = 0; i < maxclients; i++)
{
clilen[i] = sizeof(cli_addr[i]);
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);//tcp ัะพะบะตั
if (sockfd < 0)
error("ERROR opening socket");
struct sockaddr_in serv_addr;
bzero((char*)&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
int port = 30000;//ะฟะพัั
serv_addr.sin_port = htons(port);
if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
error("ERROR on binding");
if (listen(sockfd, 10) < 0)
error("ERROR listen");
HANDLE* thread;//ะผะฐััะธะฒ ะฟะพัะพะบะพะฒ ะดะปั ะบะฐะถะดะพะณะพ ะบะปะธะตะฝัะฐ ะพัะดะตะปัะฝัะน
struct arg_sa* args;
while (true)
{
newsockfd = new int[maxclients];
thread = (HANDLE*)malloc(sizeof(HANDLE) * maxclients);
args = new struct arg_sa[maxclients];
for (int i = 0; i < maxclients; i++)
{
args[i].lalk = new struct arg_s();
buffer[i] = new char[buflen2];
}
int i = -1;
while (++i < maxclients)
{
Sleep(1);
args[i].current = i;
args[i].lalk->exit = false;
thread[i] = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)(session_), args, 0, 0);
}
for (int i = 0; i < maxclients; i++)
WaitForSingleObject(thread[i], INFINITE);//ะถะดะตะผ ะทะฐะฒะตััะตะฝะธั ะฒัะตั
ะฟะพัะพะบะพะฒ
i = -1;
while (++i < maxclients)
{
shutdown(newsockfd[i], 0);
TerminateThread(thread[i], 0);
}
//delete[] newsockfd;
//free(thread);
currentclient = 0;
for (int i = 0; i < maxclients; i++)
{
//delete args[i].lalk;
//delete[] args[i].lalk->buffer;
}
//delete[] args;
}
shutdown(sockfd, 0);
WSACleanup();
return 0;
}
std::cin.ignore();
}
เชเซเชเชเชฎเชพเช, เชถเชพเชถเซเชตเชค เชฒเซเชชเชฎเชพเช, เชฆเชฐเซเช เชเซเชฒเชพเชฏเชเช เชฎเชพเชเซ เชฅเซเชฐเซเชกเซ เชฌเชจเชพเชตเชตเชพเชฎเชพเช เชเชตเซ เชเซ เช เชจเซ เชเซเชฒเชพเชฏเชจเซเช เชเชจเซเชเซเช เชฅเชพเชฏ เชคเซเชฏเชพเช เชธเซเชงเซ เชธเซเชตเซเชเชพเชฐเชตเชพเชจเซ เชฐเชพเชน เชเซเช. เชคเซ เชชเชเซ, WaitForSingleObject เชคเซเช เชฌเชงเชพ เชชเชธเชพเชฐ เชฅเชพเชฏ เชคเซเชฏเชพเช เชธเซเชงเซ เชฐเชพเชน เชเซเช เชเซ. เชฆเชฐเซเช เชเซเชฒเชพเชฏเชเชเชจเซเช เชชเซเชคเชพเชจเซเช เชธเซเชเซเช เช เชจเซ เชคเซเชจเซเช เชชเซเชคเชพเชจเซเช เชธเซเชจเซเชก เชฌเชซเชฐ เชนเซเชฏ เชเซ. เชเชเชฒเซ เชเซ, เชธเชฐเซเชตเชฐ เชชเชฐ M+1 เชธเซเชเซเชเซเชธ เชเซ, เชเซเชฏเชพเช M เช เชเซเชฒเชพเชฏเชจเซเชเชจเซ เชธเชเชเซเชฏเชพ เชเซ. เชฌเชงเชพ เชธเซเชฅเชพเชจเชพเชเชคเชฐเชฃเซ เชชเซเชฐเซเชฃ เชฅเชฏเชพ เชชเชเซ, เชฌเชงเซเช เชชเซเชจเชฐเชพเชตเชฐเซเชคเชฟเชค เชฅเชพเชฏ เชเซ.
เชนเชตเซ เชเซเชฐเชพเชนเชเชจเซ เชงเซเชฏเชพเชจเชฎเชพเช เชฒเซ:
#include <iostream>
#include <WinSock.h>
#include <vector>
#pragma comment (lib,"WS2_32.lib")
void error(const char* msg)
{
//perror(msg);
std::cout << 'n' << WSAGetLastError();
WSACleanup();
std::cin.ignore();
exit(1);
}
void bzero(char* buf, int l)
{
for (int i = 0; i < l; i++)
buf[i] = '';
}
typedef unsigned long long uint64_t;
typedef unsigned int uint32_t;
#define N 8
#define F32 0xFFFFFFFF
uint32_t RK[N];//ัะฐัะฝะดะพะฒัะต ะบะปััะธ
#define size64 sizeof(uint64_t)
#define ROR(x,n,xsize)((x>>n)|(x<<(xsize-n)))
#define ROL(x,n,xsize)((x<<n)|(x>>(xsize-n)))
#define RKEY(r)((ROR(K,r*3,size64*8))&F32)
const uint64_t K = 0x96EA704CFB1CF671;//ะบะปัั ัะธััะพะฒะฐะฝะธั
void createRoundKeys()
{
for (int i = 0; i < N; i++)
RK[i] = (ROR(K, i * 8, size64 * 8)) & F32;
}
uint32_t F(uint32_t subblk, uint32_t key)
{
return subblk + key;//ััะฝะบัะธั ัะธััะพะฒะฐะฝะธั
}
uint64_t encrypt(uint64_t block)//ะทะฐัะธััะพะฒะบะฐ ะฑะปะพะบะพะฒ ัะตััั ะคะตะนััะตะปั
{
//select subblocks
uint32_t left = (block >> 32) & F32;
uint32_t right = block & F32;
uint32_t left_, right_;//subblock in the end of round
for (int r = 0; r < N; r++)
{
uint32_t fk = F(left, RK[r]);
left_ = left;
right_ = right ^ fk;
if (r < N - 1)//swap places to next round
{
left = right_;
right = left_;
}
else//last round not swap
{
left = left_;
right = right_;
}
}
//collect subblock in block
uint64_t c_block = left;
c_block = (c_block << 32) | (right & F32);
return c_block;
}
int main()
{
keybd_event(VK_LWIN, 0, 0, 0);
keybd_event('M', 0, 0, 0);
keybd_event('M', 0, KEYEVENTF_KEYUP, 0);
keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);//ััะธ ัััะพะบะธ ัะฒะพัะฐัะธะฒะฐัั ะฒัะต ะฟัะธะปะพะถะตะฝะธั
Sleep(1000);//ััะพะฑั ัะดะตะปะฐัั ัะบัะธะฝัะพั ัะฐะฑะพัะตะณะพ ััะพะปะฐ
WSADATA ws = { 0 };
if (WSAStartup(MAKEWORD(2, 2), &ws) == 0)
{
int sockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in serv_addr, cli_addr;
bzero((char*)&serv_addr, sizeof(serv_addr));
bzero((char*)&cli_addr, sizeof(cli_addr));
serv_addr.sin_family = AF_INET;
const char* add = "127.0.0.1";//ะฐะดัะตั ัะตัะฒะตัะฐ
serv_addr.sin_addr.s_addr = inet_addr(add);
int port = 30000;//ะฟะพัั
serv_addr.sin_port = htons(port);
int servlen = sizeof(serv_addr);
int n = connect(sockfd, (struct sockaddr*)&serv_addr, servlen);
//ะฝะธะถะต ะบะพะด ะดะตะปะฐะตั ัะบัะธะฝัะพั
HDC ScreenDC = GetDC(0);
HDC MemoryDC = CreateCompatibleDC(ScreenDC);
int ScreenHeight = GetSystemMetrics(SM_CYSCREEN);
int ScreenWidth = GetSystemMetrics(SM_CXSCREEN);
ScreenWidth = ((ScreenWidth - 1) / 4 + 1) * 4;
BITMAPINFO BMI;
BMI.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
BMI.bmiHeader.biWidth = ScreenWidth;
BMI.bmiHeader.biHeight = ScreenHeight;
BMI.bmiHeader.biSizeImage = ScreenWidth * ScreenHeight * 3;
BMI.bmiHeader.biCompression = BI_RGB;
BMI.bmiHeader.biBitCount = 24;
BMI.bmiHeader.biPlanes = 1;
DWORD ScreenshotSize;
ScreenshotSize = BMI.bmiHeader.biSizeImage;
unsigned char* ImageBuffer;
HBITMAP hBitmap = CreateDIBSection(ScreenDC, &BMI, DIB_RGB_COLORS, (void**)&ImageBuffer, 0, 0);
SelectObject(MemoryDC, hBitmap);
BitBlt(MemoryDC, 0, 0, ScreenWidth, ScreenHeight, ScreenDC, 0, 0, SRCCOPY);
DeleteDC(MemoryDC);
ReleaseDC(NULL, ScreenDC);
FILE* sFile = 0;
unsigned char tgaHeader[12] = { 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
unsigned char header[6];
unsigned char tempColors = 0;
fopen_s(&sFile, "S.tga", "wb");
if (!sFile) {
exit(1);
}
header[0] = ScreenWidth % 256;
header[1] = ScreenWidth / 256;
header[2] = ScreenHeight % 256;
header[3] = ScreenHeight / 256;
header[4] = BMI.bmiHeader.biBitCount;
header[5] = 0;
fwrite(tgaHeader, 1, sizeof(tgaHeader), sFile);
fwrite(header, sizeof(header), 1, sFile);
//ะบะพะฝะตั ะทะฐะฟะธัะฐะปะธ ะธะทะพะฑัะฐะถะตะฝะธะต ะฒ ัะฐะนะป
//ัะธัััะตะผ ะฑะปะพะบะฐะผะธ ะฟะพะปะตะทะฝัั ะฝะฐะณััะทะบั ะธะทะพะฑัะฐะถะตะฝะธั ะบัะพะผะต ั
ะธะดะตัะพะฒ
createRoundKeys();
std::vector<uint64_t>* msg = new std::vector<uint64_t>(),*crpt = new std::vector<uint64_t>();
unsigned long long id;
int i = 0;
while (i < BMI.bmiHeader.biSizeImage)
{
memcpy(&id, (ImageBuffer + i), N);
msg->push_back(id);
i += 8;
}
std::cout << "i=" << i << std::endl;
uint64_t cipher;
i = 0;
char str_[N + 1];
memset(str_, 0, N);
str_[N] = '';
for (std::vector<uint64_t>::iterator it = msg->begin(); it != msg->end(); ++it)
{
cipher = encrypt(*it);
memcpy(str_, &cipher, N);
fwrite((unsigned char*)str_, sizeof(unsigned char), N, sFile);
i += 8;
}
std::cout << "i=" << i << std::endl;
//
//fwrite(ImageBuffer, BMI.bmiHeader.biSizeImage, 1, sFile);
std::cout << BMI.bmiHeader.biSizeImage << std::endl;
fclose(sFile);
DeleteObject(hBitmap);
FILE* f;
fopen_s(&f, "S.tga", "rb");
int count = 0;
if (f != NULL)
{
while (getc(f) != EOF)
count++;//ััะธัะฐะตะผ ะฑะฐะนัั ะธะทะพะฑัะฐะถะตะฝะธั ะฒ ััะตััะธะบ ััะพะฑั ะฟะพัะพะผ ะฟะตัะตะดะฐัั
fclose(f);
}
count -= 18;
std::cout << count<< std::endl;
char* s = new char[100];
_itoa_s(count, s, 100, 10);
n = send(sockfd, s, 100, 0);//ะฟะตัะตะดะฐะตะผ ััะตััะธะบ
char* buffer = new char[count];
fopen_s(&f, "S.tga", "rb");
size_t bytes;
if (f != NULL)
{
memcpy(buffer, tgaHeader, sizeof(tgaHeader));
n = send(sockfd, buffer, sizeof(tgaHeader), 0);
bzero(buffer, count);
memcpy(buffer, header, sizeof(header));
n = send(sockfd, buffer, sizeof(header), 0);
bzero(buffer, count);//ะฟะตัะตะดะฐะตะผ ั
ะธะดะตัั
for(int i=0;i<18;i++)
fgetc(f);
bzero(buffer, count);
bytes = fread(buffer, sizeof(unsigned char), count, f);
n = send(sockfd,buffer, count, 0);//ะฟะตัะตะดะฐะตะผ ัะธััะพะฒะฐะฝะฝัะต ะฑะฐะนัั ะธะทะพะฑัะฐะถะตะฝะธั
fclose(f);
}
Sleep(1000);
shutdown(sockfd, 0);
WSACleanup();
//system("del S.tga");
delete[] buffer,s;
return 0;
}
//std::cin.ignore();
}
เช เชนเซเช เชเซเชฒเชพเชฏเชจเซเชเชจเชพ เชเชพเชฐเซเชฏเชจเซเช เชชเชฐเชฟเชฃเชพเชฎ เชเซ, S.tga เชธเซเชเซเชฐเซเชจเชถเซเช เชซเชพเชเชฒ, เชเชจเซเชเซเชฐเชฟเชชเซเชเซเชก
เชเชตเซเช เชฒเชพเชเซ เชเซ เชเซ เชคเซ เชกเซเชธเซเชเชเซเชช เชเซ.
เช เชจเซ เช เชนเซเช เชชเชฐเชฟเชฃเชพเชฎ เชเซ เชเซ เชธเชฐเซเชตเชฐ เชชเชฐ เชเซเชฐเชพเชจเซเชธเชซเชฐ เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช เช เชจเซ Screen.tga เชฆเซเชตเชพเชฐเชพ เชกเซเชเซเชก เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช
เชเซเชฎ เชคเชฎเซ เชเซเช เชถเชเซ เชเซ, เชธเชพเชฎเชพเชจเซเชฏ เชซเซเชธเซเชเซเชฒ เชจเซเชเชตเชฐเซเช เชเชจเซเชเซเชฐเชฟเชชเซเชถเชจ เชฎเชพเชเซ เชฏเซเชเซเชฏ เชจเชฅเซ, เชชเชฐเชเชคเซ เชคเชฎเซ CBC เช เชจเซ CFB เชชเชฆเซเชงเชคเชฟเชเชจเซ เชเชชเชฏเซเช เชเชฐเซ เชถเชเซ เชเซ, เชคเซ เชเชฆเชพเช เชตเชงเซ เชธเชพเชฐเซ เชฐเซเชคเซ เชเชจเซเชเซเชฐเชฟเชชเซเชเซเชก เชนเชถเซ, เชชเซเชฐเชฎเชพเชฃเชฟเช เชฌเชจเชตเชพ เชฎเชพเชเซ, เชฎเซเช เชคเซเชจเซ เชคเชชเชพเชธเซเชฏเซเช เชจเชฅเซ.
เชคเชฎเชพเชฐเซเช เชงเซเชฏเชพเชจ เชฌเชฆเชฒ เชเชญเชพเชฐ!
เชธเซเชฐเซเชธ: www.habr.com