Hanomboka tsy misy sakantsakana aho, raha vao nahazo fanambarana aho (tsara, tsy dia mahery loatra, raha ny marina) ary nipoitra ny hevitra hanonta programa izay mamindra sary avy amin'ny mpanjifa mankany amin'ny server. Tsotra sa tsy izany? Eny, ho an'ny programmer za-draharaha dia ho toy izany. Tsotra ny fepetra - aza mampiasa tranomboky antoko fahatelo. Amin'ny ankapobeny, sarotra kokoa izany, fa raha tsy maintsy mandinika izany ianao ary mitady ohatra, tsara, asa toy izany. Nanapa-kevitra aho fa anjarako io asa io. Fanampin'izay, irina ny fisian'ny kaody ampy mba hapetraka ao amin'ny forum raha toa ka mila fanampiana ianao. Voalohany indrindra, nibanjina ny FTP ny masoko, teny an-dalana, ny OS izay namolavolana Windows. Ny tombony amin'ny FTP dia ny ahafahanao mamindra tsy sary fotsiny, fa rakitra rehetra amin'ny alΓ lan'izany. Rehefa avy nisintona Filezilla Server, mizara lahatahiry iray ho an'ny famakiana / fanoratana ary famoronana mpampiasa miaraka amin'ny tenimiafina, dia nanandrana nampifandray ny Filezilla Client aho, niasa ny zava-drehetra. Namorona ohatra kaody tsotra ao amin'ny C/C++ aho:
#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");
}
Raha manompo ahy ny fitadidiako, dia niasa tamin'ny localhost ny zava-drehetra, ary rehefa nampita tamin'ny tambajotra dia nisy hadisoana nitranga teo amin'ny tsipika miaraka amin'ny fandefasana. Inona no mety eto a) fohy b) tsy mila mametraka mpanjifa ianao, fa ampiasao ny fitaovana efa namboarina ho an'ny ftp avy amin'ny Microsoft. Na dia araka ny hevitro aza dia tsy maintsy ahetsiketsika amin'ny alΓ lan'ny programa sy singa. Raha fantatrao ny olana amin'ity fomba ity ary soraty ao amin'ny fanehoan-kevitra, dia ho tsara izany.
Tsy nahita valiny tao amin'ny vondrona forum aho, dia nandao ity code ity aho ary nanapa-kevitra ny hampiasa ny interface ho an'ny tambajotra socket. Efa nanana traikefa aho tamin'ny fampitana karazana chars amin'ny programa hafa. Teny an-dalana, dia afaka mamaky avy amin'ny Tanenbaum, Solosaina tambajotra, ao amin'ny toko momba ny fitaterana sosona. Misy ohatra iray momba ny mpanjifa sy ny mpizara, na dia tsy ho an'ny "mpanjifa maro - mpizara iray", fa "mpanjifa iray - mpizara iray" ihany. Satria amin'ny alalan'ny Internet ny fampitana dia mila encryption ny angona ianao. Ho an'izany dia ampiasaina ny cipher block - ny tambajotra Feistel. Plus amin'ny mpizara dia ilaina ny manao mpanjifa maromaro (mihoatra ny iray). Mba hanaovana izany dia hampiasa Threads izahay, ny sary ho an'ny fampitana dia haka ny pikantsary amin'ny efijery avy amin'ny mpanjifa, ho encryption ary ampitaina amin'ny mpizara, izay ho decrypted ary aseho avy hatrany eo amin'ny efijery amin'ny alΓ lan'ny programa default ho an'ny fanokafana * .tga sary.
Kaody mpizara:
#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();
}
Raha fintinina, amin'ny loop mandrakizay, ny kofehy dia noforonina ho an'ny mpanjifa tsirairay ary miandry ny fanekena mandra-pifandraisana ny mpanjifa. Aorian'izay, miandry ny WaitForSingleObject mandra-pahatapitry ny rehetra. Ny mpanjifa tsirairay dia manana ny socket sy ny buffer fandefasana azy manokana. Izany hoe, misy socket M+1 ao amin'ny server, izay M no isan'ny mpanjifa. Rehefa vita ny fifindrana rehetra dia miverimberina ny zava-drehetra.
Diniho izao ny mpanjifa:
#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();
}
Ity ny vokatry ny asan'ny mpanjifa, ny fisie pikantsary S.tga, voarakotra
Toa desktop izy io.
Ary izao ny vokatra nafindra tany amin'ny server ary novakian'ny Screen.tga
Araka ny hitanao, ny tambajotra Feistel mahazatra dia tsy mety amin'ny encryption, fa azonao ampiasaina ny fomba CBC sy CFB, mety ho tsara kokoa ny encryption, raha ny marina, tsy nanamarina izany aho.
Fidio ny Fiteninao
Source: www.habr.com