void cyclic_write(char* buffer, int need_to_write) {
    while (need_to_write != 0) {
        int bytes_writen = write(STDOUT_FILENO, buffer, need_to_write);

        need_to_write -= bytes_writen;
    }
}

void decrypt(unsigned char* password, unsigned char* salt) {
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();

    unsigned char key[1024];
    unsigned char iv[1024];

    memset(key, 0, sizeof key);
    memset(iv, 0, sizeof iv);

    EVP_BytesToKey(
        EVP_aes_256_cbc(),
        EVP_sha256(),
        salt,
        password, strlen(password),
        1,
        key,
        iv
    );

    EVP_DecryptInit(ctx, EVP_aes_256_cbc(), key, iv);

    int bytes_read = 0;
    unsigned char encrypted_buffer[2048];
    unsigned char decrypted_buffer[2048];
    int buffer_size = 1024;
    memset(encrypted_buffer, 0, sizeof(encrypted_buffer));
    memset(decrypted_buffer, 0, sizeof(decrypted_buffer));
    int decrypted_text_len = 0;

    while ((bytes_read = read(STDIN_FILENO, encrypted_buffer, buffer_size)) > 0) {
        EVP_DecryptUpdate(ctx, decrypted_buffer, &decrypted_text_len, encrypted_buffer, bytes_read);

        cyclic_write(decrypted_buffer, decrypted_text_len);
    }

    EVP_DecryptFinal(ctx, decrypted_buffer, &decrypted_text_len);

    cyclic_write(decrypted_buffer, decrypted_text_len);

    EVP_CIPHER_CTX_free(ctx);
}

void read_salt(unsigned char* salt) {
    int bytes_read = 0;
    int total_bytes = 0;

    // reading "Salted_"
    unsigned char buffer[100];
    memset(buffer, 0, sizeof buffer);
    while (total_bytes != strlen("Salted__")) {
        bytes_read = read(STDIN_FILENO, buffer, strlen("Salted__") - total_bytes);
        total_bytes += bytes_read;
    }

    total_bytes = 0;

    // reading salt with salt_len = PKCS5_SALT_LEN
    while (total_bytes != PKCS5_SALT_LEN) {
        bytes_read = read(STDIN_FILENO, salt + total_bytes, 1);
        total_bytes += bytes_read;
    }
}