Waxaan ku bilaabi doonaa dhib la'aan, mar aan helay waxyi (si fiican, ma ahan mid aad u xoog badan, si daacad ah) iyo fikradda ayaa kacday in aan daabaco barnaamij ka wareejinaya sawirka macmiilka ilaa server. Sahal ku filan sax? Waa hagaag, barnaamij-yaqaan khibrad leh, waxay noqon doontaa sidaas. Xaaladuhu waa sahlan yihiin - ha isticmaalin maktabadaha qolo saddexaad. Mabda 'ahaan, waa wax yar oo dhib badan, laakiin marka la eego waa inaad ogaataa oo aad raadisaa tusaalooyin, si fiican, shaqadan oo kale. Waxaan go'aansaday in hawshan ay aniga ii taallo. Waxaa dheer, waa suurad wacan in uu jiro kood ku filan si loogu dhejiyo madasha haddii aad u baahan tahay caawimaad. Ugu horreyntii, indhahaygu waxay ku dhaceen FTP, jidka, OS-ka kaas oo Windows lagu soo saarayo. Faa'iidada FTP waa inaad ku wareejin karto ma aha oo kaliya sawir, laakiin fayl kasta iyada oo loo marayo. Ka dib markii aan soo dejiyo Filezilla Server, wadaagista hal buug oo loogu talagalay akhrinta / qorista iyo abuurista isticmaale sirta ah, waxaan isku dayay inaan ku xiro Macmiilka Filezilla, wax walbaa waa shaqeeyeen. Waxaan ku abuuray tusaale kood fudud 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");
}
Haddii xusuustaydu ay ii adeegto, markaa wax walbaa waxay ku shaqeeyeen localhost, iyo marka la gudbinayo shabakada, qalad ayaa ka dhacay xariiqda diritaanka. Maxaa halkan ku habboon a) si kooban b) Uma baahnid inaad ku rakibto macmiil, laakiin isticmaal qalabkii hore loogu dhisay ee ftp ee Microsoft. Inkastoo ra'yigeyga ay tahay in lagu hawlgeliyo barnaamijyada iyo qaybaha. Haddii aad ogaato waxa dhibaatada habkani tahay oo aad ku qorto faallooyinka, way fiicnaan doontaa.
Anigoo aan jawaab ka helin kooxo badan oo goleyaal ah, waxaan ka tagay koodkan oo waxaan go'aansaday inaan isticmaalo interface-ka shabakadaha godka. Waxa aan hore u lahaa waayo-aragnimada u gudbinta barnaamijyo kala duwan oo soo jiidasho leh. Jid ahaan, waxaad ka akhrisan kartaa Tanenbaum, shabakadaha kumbuyuutarka, cutubka ku saabsan lakabka gaadiidka. Waxaa jira tusaale ahaan macmiilka iyo server-ka, inkasta oo aan loogu talagalay "macaamiil badan - hal server", laakiin kaliya "hal macmiil - hal server". Mar haddii gudbintu ka sarreyso internetka, waxaad u baahan tahay inaad sir sir xogta si uun. Taas awgeed, block cipher ayaa loo isticmaalaa - shabakadda Feitel. Lagu daro server-ka waxaa lagama maarmaan ah in la sameeyo dhowr (in ka badan hal macmiil) macaamiil. Si tan loo sameeyo, waxaan isticmaali doonaa Threads, sawirka gudbinta ayaa qaadi doona shaashadda shaashadda ee macmiilka, waa la sir doona oo loo gudbiyaa server-ka, halkaas oo laga saari doono oo isla markiiba lagu soo bandhigi doono shaashadda iyada oo loo marayo barnaamijka caadiga ah ee furitaanka * sawirada tga
Koodhka adeegaha:
#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();
}
Marka la soo koobo, wareegga daa'imka ah, dunta ayaa loo sameeyay macmiil kasta oo sug aqbal ilaa inta ay macaamiishu isku xirayaan. Taas ka dib, WaitForSingleObject waxay sugaysaa ilaa ay dhammaan ka gudbaan. Macmiil kastaa wuxuu leeyahay godad u gaar ah iyo kayd u ββgaar ah. Taasi waa, waxaa jira saldhigyada M+1 ee server-ka, halkaasoo M ay tahay tirada macaamiisha. Ka dib marka la dhammeeyo dhammaan wareejinta, wax walba ayaa soo noqnoqda.
Hadda tixgeli macmiilka:
#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();
}
Halkan waxaa ah natiijada shaqada macmiilka, faylka S.tga screenshot, oo sir ah
Waxay u egtahay inay tahay desktop-ka.
Oo halkan waa natiijadii lagu wareejiyay server-ka oo ay dejisay Screen.tga
Sida aad arki karto, shabakadda Feitel ee caadiga ah kuma habboona sirta, laakiin waxaad isticmaali kartaa hababka CBC iyo CFB, waxay u badan tahay inay si fiican u qarin doonto, si daacad ah, anigu maan hubin.
Qalbadda
Source: www.habr.com