ਪੁਰਾਣੀ ਬੈਸਾਖੀ 'ਤੇ ਪੁਰਾਣੀ ਬੈਸਾਖੀ

ਮੈਂ ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ ਸ਼ੁਰੂ ਕਰਾਂਗਾ, ਇੱਕ ਵਾਰ ਜਦੋਂ ਮੈਨੂੰ ਇੱਕ ਖੁਲਾਸਾ ਹੋਇਆ (ਚੰਗੀ ਤਰ੍ਹਾਂ, ਬਹੁਤ ਸ਼ਕਤੀਸ਼ਾਲੀ ਨਹੀਂ, ਈਮਾਨਦਾਰ ਹੋਣ ਲਈ) ਅਤੇ ਵਿਚਾਰ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਛਾਪਣ ਲਈ ਪੈਦਾ ਹੋਇਆ ਜੋ ਇੱਕ ਕਲਾਇੰਟ ਤੋਂ ਇੱਕ ਸਰਵਰ ਵਿੱਚ ਇੱਕ ਚਿੱਤਰ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਦਾ ਹੈ. ਸਧਾਰਨ ਕਾਫ਼ੀ ਸਹੀ? ਖੈਰ, ਇੱਕ ਤਜਰਬੇਕਾਰ ਪ੍ਰੋਗਰਾਮਰ ਲਈ, ਇਹ ਅਜਿਹਾ ਹੋਵੇਗਾ. ਸ਼ਰਤਾਂ ਸਧਾਰਨ ਹਨ - ਤੀਜੀ-ਧਿਰ ਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ। ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ, ਇਹ ਥੋੜਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਹੈ, ਪਰ ਇਹ ਦਿੱਤਾ ਗਿਆ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇਸਦਾ ਪਤਾ ਲਗਾਉਣਾ ਪਏਗਾ ਅਤੇ ਉਦਾਹਰਣਾਂ ਦੀ ਭਾਲ ਕਰਨੀ ਪਵੇਗੀ, ਠੀਕ ਹੈ, ਅਜਿਹਾ ਕਿੱਤਾ. ਮੈਂ ਫੈਸਲਾ ਕੀਤਾ ਕਿ ਇਹ ਕੰਮ ਮੇਰੇ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਫਾਇਦੇਮੰਦ ਹੈ ਕਿ ਕਾਫ਼ੀ ਕੋਡ ਹੋਵੇ ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਮਦਦ ਦੀ ਲੋੜ ਪੈਣ 'ਤੇ ਇਸ ਨੂੰ ਫੋਰਮ 'ਤੇ ਪੋਸਟ ਕੀਤਾ ਜਾ ਸਕੇ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਮੇਰੀ ਨਜ਼ਰ FTP 'ਤੇ ਪਈ, ਤਰੀਕੇ ਨਾਲ, ਓਐਸ ਜਿਸ ਵਿੱਚ ਵਿੰਡੋਜ਼ ਨੂੰ ਵਿਕਸਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ. 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");
}

ਜੇ ਮੇਰੀ ਮੈਮੋਰੀ ਮੇਰੀ ਸੇਵਾ ਕਰਦੀ ਹੈ, ਤਾਂ ਸਭ ਕੁਝ ਲੋਕਲਹੋਸਟ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਜਦੋਂ ਨੈੱਟਵਰਕ 'ਤੇ ਸੰਚਾਰਿਤ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਭੇਜਣ ਦੇ ਨਾਲ ਲਾਈਨ ਵਿੱਚ ਇੱਕ ਗਲਤੀ ਆਈ ਹੈ. ਇੱਥੇ ਕੀ ਸੁਵਿਧਾਜਨਕ ਹੈ a) ਸੰਖੇਪ ਵਿੱਚ b) ਤੁਹਾਨੂੰ ਇੱਕ ਕਲਾਇੰਟ ਸਥਾਪਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ, ਪਰ Microsoft ਤੋਂ ftp ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਬਿਲਟ-ਇਨ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਹਾਲਾਂਕਿ ਮੇਰੀ ਰਾਏ ਵਿੱਚ ਇਹ ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ ਭਾਗਾਂ ਦੁਆਰਾ ਕਿਰਿਆਸ਼ੀਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਇਹ ਸਮਝਦੇ ਹੋ ਕਿ ਇਸ ਵਿਧੀ ਦੀ ਸਮੱਸਿਆ ਕੀ ਹੈ ਅਤੇ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਲਿਖੋ, ਤਾਂ ਇਹ ਬਹੁਤ ਵਧੀਆ ਹੋਵੇਗਾ.

ਫੋਰਮਾਂ ਦੇ ਝੁੰਡ 'ਤੇ ਕੋਈ ਜਵਾਬ ਨਾ ਮਿਲਣ ਕਰਕੇ, ਮੈਂ ਇਸ ਕੋਡ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਅਤੇ ਸਾਕਟ ਨੈਟਵਰਕ ਲਈ ਇੰਟਰਫੇਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ. ਮੈਨੂੰ ਪਹਿਲਾਂ ਹੀ ਕਿਸੇ ਹੋਰ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਐਰੇ ਨੂੰ ਪਾਸ ਕਰਨ ਦਾ ਅਨੁਭਵ ਸੀ। ਤਰੀਕੇ ਨਾਲ, ਤੁਸੀਂ ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਬਾਰੇ ਅਧਿਆਇ ਵਿੱਚ ਟੈਨੇਨਬੌਮ, ਕੰਪਿਊਟਰ ਨੈਟਵਰਕਸ ਤੋਂ ਪੜ੍ਹ ਸਕਦੇ ਹੋ। ਇੱਕ ਕਲਾਇੰਟ ਅਤੇ ਇੱਕ ਸਰਵਰ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ, ਹਾਲਾਂਕਿ "ਬਹੁਤ ਸਾਰੇ ਕਲਾਇੰਟਸ - ਇੱਕ ਸਰਵਰ" ਕੁਨੈਕਸ਼ਨ ਲਈ ਨਹੀਂ, ਪਰ ਸਿਰਫ "ਇੱਕ ਕਲਾਇੰਟ - ਇੱਕ ਸਰਵਰ" ਲਈ। ਕਿਉਂਕਿ ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਇੰਟਰਨੈਟ ਤੇ ਹੈ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਡੇਟਾ ਨੂੰ ਐਨਕ੍ਰਿਪਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਇਸਦੇ ਲਈ, ਇੱਕ ਬਲਾਕ ਸਿਫਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ - ਫੀਸਟਲ ਨੈਟਵਰਕ. ਨਾਲ ਹੀ ਸਰਵਰ 'ਤੇ ਕਈ (ਇੱਕ ਤੋਂ ਵੱਧ ਗਾਹਕ) ਗਾਹਕ ਬਣਾਉਣਾ ਜ਼ਰੂਰੀ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਥ੍ਰੈਡਸ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਪ੍ਰਸਾਰਣ ਲਈ ਚਿੱਤਰ ਕਲਾਇੰਟ ਤੋਂ ਸਕ੍ਰੀਨ ਦਾ ਇੱਕ ਸਕ੍ਰੀਨਸ਼ੌਟ ਲਵੇਗਾ, ਏਨਕ੍ਰਿਪਟ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਸਰਵਰ 'ਤੇ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਵੇਗਾ, ਜਿੱਥੇ ਇਸਨੂੰ ਡੀਕ੍ਰਿਪਟ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਖੋਲ੍ਹਣ ਲਈ ਡਿਫੌਲਟ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ ਤੁਰੰਤ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ * .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