Π©Π΅ Π·Π°ΠΏΠΎΡΠ½Π° Π±Π΅Π·ΠΏΡΠΎΠ±Π»Π΅ΠΌΠ½ΠΎ, ΡΠ»Π΅Π΄ ΠΊΠ°ΡΠΎ ΠΏΠΎΠ»ΡΡΠΈΡ ΡΠ°Π·ΠΊΡΠΈΡΠΈΠ΅ (Π΅, Π½Π΅ ΠΎΡΠΎΠ±Π΅Π½ΠΎ ΠΌΠΎΡΠ½ΠΎ, ΡΠ΅ΡΡΠ½ΠΎ ΠΊΠ°Π·Π°Π½ΠΎ) ΠΈ ΡΠ΅ ΠΏΠΎΡΠ²ΠΈ ΠΈΠ΄Π΅ΡΡΠ° Π΄Π° ΠΎΡΠΏΠ΅ΡΠ°ΡΠ°ΠΌ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠ°, ΠΊΠΎΡΡΠΎ ΠΏΡΠ΅Ρ Π²ΡΡΠ»Ρ ΠΈΠ·ΠΎΠ±ΡΠ°ΠΆΠ΅Π½ΠΈΠ΅ ΠΎΡ ΠΊΠ»ΠΈΠ΅Π½Ρ Π½Π° ΡΡΡΠ²ΡΡ. ΠΠΎΡΡΠ°ΡΡΡΠ½ΠΎ ΠΏΡΠΎΡΡΠΎ, Π½Π°Π»ΠΈ? Π, Π·Π° ΠΎΠΏΠΈΡΠ΅Π½ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΈΡΡ ΡΠ΅ Π±ΡΠ΄Π΅ ΡΠ°ΠΊΠ°. Π£ΡΠ»ΠΎΠ²ΠΈΡΡΠ° ΡΠ° ΠΏΡΠΎΡΡΠΈ - Π½Π΅ ΠΈΠ·ΠΏΠΎΠ»Π·Π²Π°ΠΉΡΠ΅ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ Π½Π° ΡΡΠ΅ΡΠΈ ΡΡΡΠ°Π½ΠΈ. ΠΠΎ ΠΏΡΠΈΠ½ΡΠΈΠΏ Π΅ ΠΌΠ°Π»ΠΊΠΎ ΠΏΠΎ-ΡΠ»ΠΎΠΆΠ½ΠΎ, Π½ΠΎ ΠΊΠ°ΡΠΎ ΡΠ΅ ΠΈΠΌΠ° ΠΏΡΠ΅Π΄Π²ΠΈΠ΄, ΡΠ΅ ΡΡΡΠ±Π²Π° Π΄Π° Π³ΠΎ ΡΠ°Π·Π±Π΅ΡΠ΅ΡΠ΅ ΠΈ Π΄Π° ΠΏΠΎΡΡΡΡΠΈΡΠ΅ ΠΏΡΠΈΠΌΠ΅ΡΠΈ, Π΄ΠΎΠ±ΡΠ΅, ΡΠ°ΠΊΠ°Π²Π° ΠΏΡΠΎΡΠ΅ΡΠΈΡ. Π Π΅ΡΠΈΡ , ΡΠ΅ ΡΠ°Π·ΠΈ Π·Π°Π΄Π°ΡΠ° Π΅ ΠΌΠΎΡ. ΠΡΠ²Π΅Π½ ΡΠΎΠ²Π° Π΅ ΠΆΠ΅Π»Π°ΡΠ΅Π»Π½ΠΎ Π΄Π° ΠΈΠΌΠ° Π΄ΠΎΡΡΠ°ΡΡΡΠ½ΠΎ ΠΊΠΎΠ΄, Π·Π° Π΄Π° ΠΌΠΎΠΆΠ΅ Π΄Π° Π±ΡΠ΄Π΅ ΠΏΡΠ±Π»ΠΈΠΊΡΠ²Π°Π½ Π²ΡΠ² ΡΠΎΡΡΠΌΠ°, Π°ΠΊΠΎ ΠΈΠΌΠ°ΡΠ΅ Π½ΡΠΆΠ΄Π° ΠΎΡ ΠΏΠΎΠΌΠΎΡ. ΠΡΡΠ²ΠΎ, ΠΏΠΎΠ³Π»Π΅Π΄ΡΡ ΠΌΠΈ ΠΏΠ°Π΄Π½Π° Π²ΡΡΡ Ρ FTP, ΠΌΠ΅ΠΆΠ΄Ρ Π΄ΡΡΠ³ΠΎΡΠΎ, ΠΎΠΏΠ΅ΡΠ°ΡΠΈΠΎΠ½Π½Π°ΡΠ° ΡΠΈΡΡΠ΅ΠΌΠ°, Π² ΠΊΠΎΡΡΠΎ ΡΠ΅ ΡΠ°Π·ΡΠ°Π±ΠΎΡΠ²Π° 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");
}
ΠΠΊΠΎ ΠΏΠ°ΠΌΠ΅ΡΡΠ° ΠΌΠΈ Π½Π΅ ΠΌΠ΅ Π»ΡΠΆΠ΅, ΡΠΎΠ³Π°Π²Π° Π²ΡΠΈΡΠΊΠΎ ΡΠ°Π±ΠΎΡΠΈ Π½Π° localhost ΠΈ ΠΏΡΠΈ ΠΏΡΠ΅Π΄Π°Π²Π°Π½Π΅ ΠΏΠΎ ΠΌΡΠ΅ΠΆΠ°ΡΠ° Π²ΡΠ·Π½ΠΈΠΊΠ½Π° Π³ΡΠ΅ΡΠΊΠ° Π² ΡΠ΅Π΄Π° Ρ ΠΈΠ·ΠΏΡΠ°ΡΠ°Π½Π΅. ΠΠ°ΠΊΠ²ΠΎ Π΅ ΡΠ΄ΠΎΠ±Π½ΠΎ ΡΡΠΊ Π°) Π½Π°ΠΊΡΠ°ΡΠΊΠΎ Π±) Π½Π΅ Π΅ Π½ΡΠΆΠ½ΠΎ Π΄Π° ΠΈΠ½ΡΡΠ°Π»ΠΈΡΠ°ΡΠ΅ ΠΊΠ»ΠΈΠ΅Π½Ρ, Π° Π΄Π° ΠΈΠ·ΠΏΠΎΠ»Π·Π²Π°ΡΠ΅ Π²Π΅ΡΠ΅ Π²Π³ΡΠ°Π΄Π΅Π½ΠΈΡ ΠΈΠ½ΡΡΡΡΠΌΠ΅Π½Ρ Π·Π° ftp ΠΎΡ Microsoft. ΠΡΠΏΡΠ΅ΠΊΠΈ ΡΠ΅ ΡΠΏΠΎΡΠ΅Π΄ ΠΌΠ΅Π½ ΡΡΡΠ±Π²Π° Π΄Π° ΡΠ΅ Π°ΠΊΡΠΈΠ²ΠΈΡΠ° ΡΡΠ΅Π· ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΈ ΠΈ ΠΊΠΎΠΌΠΏΠΎΠ½Π΅Π½ΡΠΈ. ΠΠΊΠΎ ΡΠ°Π·Π±Π΅ΡΠ΅ΡΠ΅ ΠΊΠ°ΠΊΡΠ² Π΅ ΠΏΡΠΎΠ±Π»Π΅ΠΌΡΡ Π½Π° ΡΠΎΠ·ΠΈ ΠΌΠ΅ΡΠΎΠ΄ ΠΈ Π½Π°ΠΏΠΈΡΠ΅ΡΠ΅ Π² ΠΊΠΎΠΌΠ΅Π½ΡΠ°ΡΠΈΡΠ΅, ΡΠ΅ Π±ΡΠ΄Π΅ ΡΡΡΠ°Ρ ΠΎΡΠ½ΠΎ.
Π‘Π»Π΅Π΄ ΠΊΠ°ΡΠΎ Π½Π΅ Π½Π°ΠΌΠ΅ΡΠΈΡ ΠΎΡΠ³ΠΎΠ²ΠΎΡ Π² ΠΊΡΠΏ ΡΠΎΡΡΠΌΠΈ, ΠΎΡΡΠ°Π²ΠΈΡ ΡΠΎΠ·ΠΈ ΠΊΠΎΠ΄ ΠΈ ΡΠ΅ΡΠΈΡ Π΄Π° ΠΈΠ·ΠΏΠΎΠ»Π·Π²Π°ΠΌ ΠΈΠ½ΡΠ΅ΡΡΠ΅ΠΉΡΠ° Π·Π° ΡΠΎΠΊΠ΅Ρ ΠΌΡΠ΅ΠΆΠΈ. ΠΠ΅ΡΠ΅ ΠΈΠΌΠ°Ρ ΠΎΠΏΠΈΡ Ρ ΠΏΡΠ΅Π΄Π°Π²Π°Π½Π΅ΡΠΎ Π½Π° ΠΌΠ°ΡΠΈΠ² ΠΎΡ Π·Π½Π°ΡΠΈ Π½Π° Π΄ΡΡΠ³Π° ΠΏΡΠΎΠ³ΡΠ°ΠΌΠ°. ΠΠ΅ΠΆΠ΄Ρ Π΄ΡΡΠ³ΠΎΡΠΎ, ΠΌΠΎΠΆΠ΅ΡΠ΅ Π΄Π° ΠΏΡΠΎΡΠ΅ΡΠ΅ΡΠ΅ ΠΎΡ Π’Π°Π½Π΅Π½Π±Π°ΡΠΌ, ΠΠΎΠΌΠΏΡΡΡΡΠ½ΠΈ ΠΌΡΠ΅ΠΆΠΈ, Π² Π³Π»Π°Π²Π°ΡΠ° Π·Π° ΡΡΠ°Π½ΡΠΏΠΎΡΡΠ½ΠΈΡ ΡΠ»ΠΎΠΉ. ΠΠΌΠ° ΠΏΡΠΈΠΌΠ΅Ρ Π·Π° ΠΊΠ»ΠΈΠ΅Π½Ρ ΠΈ ΡΡΡΠ²ΡΡ, Π½ΠΎ Π½Π΅ Π·Π° Π²ΡΡΠ·ΠΊΠ°ΡΠ° "ΠΌΠ½ΠΎΠ³ΠΎ ΠΊΠ»ΠΈΠ΅Π½ΡΠΈ - Π΅Π΄ΠΈΠ½ ΡΡΡΠ²ΡΡ", Π° ΡΠ°ΠΌΠΎ "Π΅Π΄ΠΈΠ½ ΠΊΠ»ΠΈΠ΅Π½Ρ - Π΅Π΄ΠΈΠ½ ΡΡΡΠ²ΡΡ". Π’ΡΠΉ ΠΊΠ°ΡΠΎ ΠΏΡΠ΅Π΄Π°Π²Π°Π½Π΅ΡΠΎ Π΅ ΠΏΠΎ ΠΈΠ½ΡΠ΅ΡΠ½Π΅Ρ, ΡΡΡΠ±Π²Π° Π΄Π° ΡΠΈΡΡΠΎΠ²Π°ΡΠ΅ Π΄Π°Π½Π½ΠΈΡΠ΅ ΠΏΠΎ Π½ΡΠΊΠ°ΠΊΡΠ² Π½Π°ΡΠΈΠ½. ΠΠ° ΡΠΎΠ²Π° ΡΠ΅ ΠΈΠ·ΠΏΠΎΠ»Π·Π²Π° Π±Π»ΠΎΠΊΠΎΠ² ΡΠΈΡΡΡ - ΠΌΡΠ΅ΠΆΠ°ΡΠ° Π½Π° Feistel. ΠΡΠ²Π΅Π½ ΡΠΎΠ²Π° Π½Π° ΡΡΡΠ²ΡΡΠ° Π΅ Π½Π΅ΠΎΠ±Ρ ΠΎΠ΄ΠΈΠΌΠΎ Π΄Π° ΡΠ΅ Π½Π°ΠΏΡΠ°Π²ΡΡ Π½ΡΠΊΠΎΠ»ΠΊΠΎ (ΠΏΠΎΠ²Π΅ΡΠ΅ ΠΎΡ Π΅Π΄ΠΈΠ½ ΠΊΠ»ΠΈΠ΅Π½Ρ) ΠΊΠ»ΠΈΠ΅Π½ΡΠΈ. ΠΠ° Π΄Π° Π½Π°ΠΏΡΠ°Π²ΠΈΠΌ ΡΠΎΠ²Π°, ΡΠ΅ ΠΈΠ·ΠΏΠΎΠ»Π·Π²Π°ΠΌΠ΅ Threads, ΠΈΠ·ΠΎΠ±ΡΠ°ΠΆΠ΅Π½ΠΈΠ΅ΡΠΎ Π·Π° ΠΏΡΠ΅Π΄Π°Π²Π°Π½Π΅ ΡΠ΅ Π½Π°ΠΏΡΠ°Π²ΠΈ Π΅ΠΊΡΠ°Π½Π½Π° ΡΠ½ΠΈΠΌΠΊΠ° Π½Π° Π΅ΠΊΡΠ°Π½Π° ΠΎΡ ΠΊΠ»ΠΈΠ΅Π½ΡΠ°, ΡΠ΅ Π±ΡΠ΄Π΅ ΠΊΡΠΈΠΏΡΠΈΡΠ°Π½ΠΎ ΠΈ ΠΏΡΠ΅Π΄Π°Π΄Π΅Π½ΠΎ Π½Π° ΡΡΡΠ²ΡΡΠ°, ΠΊΡΠ΄Π΅ΡΠΎ ΡΠ΅ Π±ΡΠ΄Π΅ Π΄Π΅ΠΊΡΠΈΠΏΡΠΈΡΠ°Π½ΠΎ ΠΈ Π²Π΅Π΄Π½Π°Π³Π° ΡΠ΅ ΡΠ΅ ΠΏΠΎΠΊΠ°ΠΆΠ΅ Π½Π° Π΅ΠΊΡΠ°Π½Π° ΡΡΠ΅Π· ΠΏΡΠΎΠ³ΡΠ°ΠΌΠ°ΡΠ° ΠΏΠΎ ΠΏΠΎΠ΄ΡΠ°Π·Π±ΠΈΡΠ°Π½Π΅ Π·Π° ΠΎΡΠ²Π°ΡΡΠ½Π΅ * .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
ΠΠ°ΠΊΡΠΎ ΠΌΠΎΠΆΠ΅ΡΠ΅ Π΄Π° Π²ΠΈΠ΄ΠΈΡΠ΅, ΠΎΠ±ΠΈΡΠ°ΠΉΠ½Π°ΡΠ° ΠΌΡΠ΅ΠΆΠ° Π½Π° Feistel Π½Π΅ Π΅ ΠΏΠΎΠ΄Ρ ΠΎΠ΄ΡΡΠ° Π·Π° ΠΊΡΠΈΠΏΡΠΈΡΠ°Π½Π΅, Π½ΠΎ ΠΌΠΎΠΆΠ΅ΡΠ΅ Π΄Π° ΠΈΠ·ΠΏΠΎΠ»Π·Π²Π°ΡΠ΅ ΠΌΠ΅ΡΠΎΠ΄ΠΈΡΠ΅ CBC ΠΈ CFB, Π²Π΅ΡΠΎΡΡΠ½ΠΎ ΡΠ΅ Π±ΡΠ΄Π΅ ΠΏΠΎ-Π΄ΠΎΠ±ΡΠ΅ ΠΊΡΠΈΠΏΡΠΈΡΠ°Π½Π°, ΡΠ΅ΡΡΠ½ΠΎ ΠΊΠ°Π·Π°Π½ΠΎ, Π½Π΅ Π³ΠΎ ΠΏΡΠΎΠ²Π΅ΡΠΈΡ .
Π‘ΠΏΠ°ΡΠΈΠ±ΠΎ Π·Π° Π²Π½ΠΈΠΌΠ°Π½ΠΈΠ΅!
ΠΠ·ΡΠΎΡΠ½ΠΈΠΊ: www.habr.com