แแแแแฌแงแแ แฃแแ แแแแแแแ, แแ แแฎแแ แแ แแฅแแแแ แแแแแชแฎแแแแแ (แแแ แแแ แ แแ แแแฅแแ, แแ แช แแกแ แซแแแแ แ) แแ แแแฉแแแ แแแแ แแแแแแแญแแ แแ แแแ แแแ, แ แแแแแแช แกแฃแ แแแก แแแแแแขแแแแ แกแแ แแแ แแ แแแแแกแชแแแก. แกแแแแแ แแกแแ แแแ แขแแแ แแ แ? แแแ แแ, แแแแแชแแแแ แแ แแแ แแแแกแขแแกแแแแก แแก แแกแ แแฅแแแแ. แแแ แแแแแ แแแ แขแแแแ - แแ แแแแแแงแแแแ แแแกแแแ แแฎแแ แแก แแแแแแแแแแแแ. แแ แแแชแแแจแ, แแก แชแแขแ แฃแคแ แ แ แแฃแแแ, แแแแ แแ แแแแก แแแแแแแแกแฌแแแแแแ, แ แแ แแฅแแแ แฃแแแ แแแแ แแแแแ แแ แแแซแแแแแ แแแแแแแแแแ, แแแ แแ, แแกแแแ แแแฃแแแชแแ. แแแแแแฌแงแแแขแ, แ แแ แแก แแแแชแแแ แฉแแแแ แแงแ. แแแ แแ แแแแกแ, แกแแกแฃแ แแแแแ แแงแแก แกแแแแแ แแกแ แแแแ, แ แแแ แแก แแแแแฅแแแงแแแแก แคแแ แฃแแแ แแแฎแแแ แแแแก แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ. แฃแแแ แแแแแก แงแแแแแกแ, แฉแแแ แแแแแ แแแแชแ FTP-แแ, แกแฎแแแแ แจแแ แแก, OS-แแ, แ แแแแแจแแช แแฃแจแแแแแแ Windows. FTP-แแก แฃแแแ แแขแแกแแแ แแก แแ แแก, แ แแ แแแกแ แกแแจแฃแแแแแแ แจแแแแซแแแแ แแแแแแขแแแแ แแ แ แแฎแแแแ แกแฃแ แแแ, แแ แแแแ แแแแแกแแแแ แ แคแแแแ. Filezilla Server-แแก แฉแแแแขแแแ แแแแก, แแ แแ แแแขแแแแแแก แฌแแแแแฎแแแก/แฌแแ แแก แแ แแแ แแแแ แแแแฎแแแ แแแแแก แจแแฅแแแแก แแแแแแ แแแแก แจแแแแแ, แแชแแแ Filezilla Client-แแก แแแแแแจแแ แแแ, แงแแแแแคแแ แ แแฃแจแแแแแ. แแ แจแแแฅแแแแ แแแ แขแแแ แแแแแก แแแแแแแแ 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");
}
แแฃ แแแฎแกแแแ แแแ แแแแกแแฎแฃแ แแแ, แแแจแแ แงแแแแแคแแ แ แแฃแจแแแแแ แแแแแแฃแ แฐแแกแขแแ แแ แฅแกแแแจแ แแแแแชแแแแกแแก แแแฎแแ แจแแชแแแแ แแแแแแแแแก แฎแแแจแ. แแฅ แแแกแแฎแแ แฎแแแแแแ แ) แแแแแแ แ) แแฅแแแ แแ แแญแแ แแแแแ แแแแแแขแแก แแแงแแแแแ, แแ แแแแ แแแแแแงแแแแ Microsoft-แแก ftp-แแกแแแแก แฃแแแ แฉแแจแแแแแฃแแ แแแกแขแ แฃแแแแขแ. แแฃแแชแ, แฉแแแ แแแ แแ, แแก แฃแแแ แแแแฅแขแแฃแ แแแก แแ แแแ แแแแแแกแ แแ แแแแแแแแแขแแแแก แกแแจแฃแแแแแแ. แแฃ แแแแ แแแแแ แ แ แแ แแก แแ แแแแแแแก แแ แแแแแแ แแ แแแฌแแ แแ แแแแแแขแแ แแแจแ, แแแ แแ แแฅแแแแ.
แแแก แจแแแแแ, แ แแช แแแ แแแแแแ แแแกแฃแฎแ แคแแ แฃแแแแแก แแแแแฃแแแ, แแแแขแแแ แแก แแแแ แแ แแแแแแฌแงแแแขแ แแแแแแแงแแแแแแแ แแแขแแ แคแแแกแ แกแแแแขแแแแก แฅแกแแแแแแกแแแแก. แแ แฃแแแ แแฅแแแแ แกแแแแแแแแแแก แแแกแแแแก แกแฎแแ แแ แแแ แแแแแ แแแแแชแแแแก แแแแแชแแแแแแ. แกแฎแแแแ แจแแ แแก, แจแแแแซแแแแ แฌแแแแแแฎแแ Tanenbaum-แแแ, แแแแแแฃแขแแ แฃแแ แฅแกแแแแแ, แกแแขแ แแแกแแแ แขแ แคแแแแก แจแแกแแฎแแ แแแแจแ. แแ แกแแแแแก แแแแแแขแแกแ แแ แกแแ แแแ แแก แแแแแแแแ, แแฃแแชแ แแ แ "แแแแ แ แแแแแแขแ - แแ แแ แกแแ แแแ แ" แแแแจแแ แแกแแแแก, แแ แแแแ แแฎแแแแ "แแ แแ แแแแแแขแ - แแ แแ แกแแ แแแ แ". แแแแก แแแแ, แ แแ แแแแแชแแแ แฎแแแแ แแแขแแ แแแขแแ, แแฅแแแ แฃแแแ แแแจแแคแ แแ แแแแแชแแแแแ แ แแแแ แแ. แแแแกแแแแก แแแแแแงแแแแแ แแแแแแก แจแแคแ แ - Feistel แฅแกแแแ. แแแฃแก แกแแ แแแ แแ แแฃแชแแแแแแแแ แ แแแแแแแแ (แแ แแแ แแแขแ แแแแแแขแแก) แแแแแแขแแก แจแแฅแแแ. แแแแกแแแแแก แฉแแแ แแแแแแแงแแแแแ Threads-แก, แแแแแกแแชแแแ แกแฃแ แแแ แแแแแแฆแแแก แแแ แแแแก แกแฃแ แแแก แแแแแแขแแกแแแ, แแแจแแคแ แฃแแ แแ แแแแแแชแแแ แกแแ แแแ แแ, แกแแแแช แแก แแแแจแแคแ แแแ แแ แแแฃแงแแแแแแแแ แแแแแฉแแแแแ แแแ แแแแ แแแฎแกแแแก แแแแฃแแแกแฎแแแแ แแ แแแ แแแแก แแแจแแแแแแ * .แขแแ แกแฃแ แแแแแ.
แกแแ แแแ แแก แแแแ:
#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-แ
แ แแแแ แช แฎแแแแแ, แฉแแแฃแแแแ แแแ Feistel แฅแกแแแ แแ แแ แแก แจแแกแแคแแ แแกแ แแแจแแคแแ แแกแแแแก, แแแแ แแ แจแแแแซแแแแ แแแแแแงแแแแ CBC แแ CFB แแแแแแแแ, แแแแแ แฃแแแแแกแ แแฅแแแแ แแแจแแคแ แฃแแ, แกแแแแ แแแ แแแแฎแ แแ, แแ แแแแแแแแแฌแแ.
แแแแ แแแแแแแ!
แฌแงแแ แ: www.habr.com