আমি সিটিতে কীভাবে 6464 এনকোড (ডিকোড) করব?

131

আমার স্বাক্ষরবিহীন চর ভেরিয়েবলে বাইনারি ডেটা রয়েছে। আমাকে সেগুলিতে সিএম পিইএম বেস 64 এ রূপান্তর করতে হবে। আমি ওপেনসেল লাইব্রেরিতে দেখেছি তবে আমি কোনও ফাংশন খুঁজে পাইনি। কোন শরীরের কোন ধারণা আছে?

c  base64 
11
আমার পরীক্ষিত বেস 64 এবং আনবেস 64 ফাংশন সহ একটি গিথুব সংগ্রহস্থল রয়েছে। আপনার কেবলমাত্র শিরোনামটি
— ববোবলো
দুর্ভাগ্যক্রমে এখানে বেশিরভাগ উত্তর পুরোপুরি অফ-টপিক। সি ++ সি হয় না
— জো কোডার

উত্তর:

106

এখানে আমি ব্যবহার করছি:

#include <stdint.h>
#include <stdlib.h>


static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
                                'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
                                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
                                'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
                                'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
                                'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
                                'w', 'x', 'y', 'z', '0', '1', '2', '3',
                                '4', '5', '6', '7', '8', '9', '+', '/'};
static char *decoding_table = NULL;
static int mod_table[] = {0, 2, 1};


char *base64_encode(const unsigned char *data,
                    size_t input_length,
                    size_t *output_length) {

    *output_length = 4 * ((input_length + 2) / 3);

    char *encoded_data = malloc(*output_length);
    if (encoded_data == NULL) return NULL;

    for (int i = 0, j = 0; i < input_length;) {

        uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0;
        uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0;
        uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0;

        uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;

        encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
        encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
        encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
        encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];
    }

    for (int i = 0; i < mod_table[input_length % 3]; i++)
        encoded_data[*output_length - 1 - i] = '=';

    return encoded_data;
}


unsigned char *base64_decode(const char *data,
                             size_t input_length,
                             size_t *output_length) {

    if (decoding_table == NULL) build_decoding_table();

    if (input_length % 4 != 0) return NULL;

    *output_length = input_length / 4 * 3;
    if (data[input_length - 1] == '=') (*output_length)--;
    if (data[input_length - 2] == '=') (*output_length)--;

    unsigned char *decoded_data = malloc(*output_length);
    if (decoded_data == NULL) return NULL;

    for (int i = 0, j = 0; i < input_length;) {

        uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
        uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];

        uint32_t triple = (sextet_a << 3 * 6)
        + (sextet_b << 2 * 6)
        + (sextet_c << 1 * 6)
        + (sextet_d << 0 * 6);

        if (j < *output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
        if (j < *output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
        if (j < *output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
    }

    return decoded_data;
}


void build_decoding_table() {

    decoding_table = malloc(256);

    for (int i = 0; i < 64; i++)
        decoding_table[(unsigned char) encoding_table[i]] = i;
}


void base64_cleanup() {
    free(decoding_table);
}

মনে রাখবেন যে ডিকোডিংয়ের সময় এটি কোনও ত্রুটি-চেকিং করে না - নন বেস 64 এনকোডড ডেটা প্রক্রিয়া করবে।

— ryyst
সূত্র
7
কোনও লাইব্রেরি থাকলে এটি ব্যবহার করার কোনও মানে হয় না।
— দিয়াগো ভুইটাসেন
11
আপনি বেস 64 এবং এনকোডের শুরুতে ব্যবহার করে লিবিএম এবং ম্যাথ এইচ "নির্ভরতা" পাশাপাশি ভাসমান পয়েন্ট অপারেশনগুলির (যা কিছু হার্ডওয়্যারে ধীর গতির) প্রয়োজন তা এড়িয়ে যেতে পারেন *output_length = ((input_length - 1) / 3) * 4 + 4;।
— ফ্যাবিয়ান হেনজে
9
আমি বুঝতে পেরেছি এটি "কোনও ত্রুটি পরীক্ষা করা নয়", তবে বিশেষত খেয়াল করুন যে যদিও ডিকোডারে ডিকোডিং টেবিলটি 256 এর অ্যারে, যেহেতু চর বেশিরভাগ আর্কিটেকচারে স্বাক্ষরিত, আপনি সত্যই -128 থেকে 127 পর্যন্ত সূচী করছেন high বিট সেট আপনাকে বরাদ্দ মেমরির বাইরে পড়তে বাধ্য করবে। ডেটা লুকুকে একটি স্বাক্ষরবিহীন চর হতে বাধ্য করে তা পরিষ্কার করে দেয়। আপনি আবর্জনার জন্য এখনও আবর্জনা খুঁজে পেয়েছেন, তবে আপনি সেগফোল্ট করবেন না।
— বিটমুশের
1
সমস্যা আউট-অফ-বাউন্ড আপনি একটি অ্যারে আছে build_decoding_table। encoding_table[64]থেকে encoding_table[255]কোন অস্তিত্ব নেই।
— ববোবোবো
3
"=" প্যাডিংগুলি অনুপস্থিত রয়েছে এমন পরিস্থিতিতে ডিকোডিংও পরিচালনা করে না। একসাথে অন্যান্য সমস্ত ত্রুটিগুলির সাথে একটি খুব খারাপ বাস্তবায়ন।
— লথার
56

আমি জানি এই প্রশ্নটি বেশ পুরানো, তবে যে পরিমাণ সমাধান দেওয়া হয়েছে তাতে আমি বিভ্রান্ত হয়ে পড়েছিলাম - তাদের প্রত্যেকেই দ্রুত এবং উন্নত বলে দাবি করছে। বেস 64 টি এনকোডার এবং ডিকোডারগুলির সাথে তুলনা করার জন্য আমি গিথুবে একটি প্রকল্প একসাথে রেখেছি: https://github.com/gaspardpetit/base64/

এই মুহুর্তে, আমি নিজেকে সি অ্যালগরিদমে সীমাবদ্ধ রাখিনি - যদি একটি বাস্তবায়ন সি ++ এ ভাল সম্পাদন করে তবে এটি সহজে সিতে ব্যাকপোর্ট করা যায় এছাড়াও ভিজ্যুয়াল স্টুডিও 2015 ব্যবহার করে পরীক্ষাও নেওয়া হয়েছিল If জিসিসি, আমার অতিথি হও।

দ্রুততম এনকোডার্স: আমি যে দুটি দ্রুত এনকোডার বাস্তবায়ন পেয়েছি তা হ'ল জনি ম্যালিনেনের http://web.mit.edu/freebsd/head/contrib/wpa/src/utils/base64.c এ এবং https://opensource.apple এ অ্যাপাচি .কম / সোর্স / কুইকটাইমস্ট্রিমিং সার্ভার / কুইকটাইমস্ট্রিমিং সার্ভার -452 / কমন ইউটিলিটিস লাইব / বেস 64 ।

আমি এখন পর্যন্ত বিভিন্ন অ্যালগরিদমগুলি ব্যবহার করে 32K ডেটা এনকোড করার সময় (মাইক্রোসেকেন্ডে) এখানে রয়েছে:

jounimalinen                25.1544
apache                      25.5309
NibbleAndAHalf              38.4165
internetsoftwareconsortium  48.2879
polfosol                    48.7955
wikibooks_org_c             51.9659
gnome                       74.8188
elegantdice                 118.899
libb64                      120.601
manuelmartinez              120.801
arduino                     126.262
daedalusalpha               126.473
CppCodec                    151.866
wikibooks_org_cpp           343.2
adp_gmbh                    381.523
LihO                        406.693
libcurl                     3246.39
user152949                  4828.21

(এই প্রশ্নের অন্য উত্তরে জমা হওয়া রেনা নিফেনিগারের সমাধানটি এখানে adp_gmbh হিসাবে তালিকাভুক্ত করা হয়েছে)।

এখানে জনি ম্যালিনেনের একজন যে আমি একটি স্ট্যান্ড :: স্ট্রিং ফিরিয়ে দিতে সামান্য পরিবর্তন করেছি:

/*
* Base64 encoding/decoding (RFC1341)
* Copyright (c) 2005-2011, Jouni Malinen <j@w1.fi>
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/

// 2016-12-12 - Gaspard Petit : Slightly modified to return a std::string 
// instead of a buffer allocated with malloc.

#include <string>

static const unsigned char base64_table[65] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/**
* base64_encode - Base64 encode
* @src: Data to be encoded
* @len: Length of the data to be encoded
* @out_len: Pointer to output length variable, or %NULL if not used
* Returns: Allocated buffer of out_len bytes of encoded data,
* or empty string on failure
*/
std::string base64_encode(const unsigned char *src, size_t len)
{
    unsigned char *out, *pos;
    const unsigned char *end, *in;

    size_t olen;

    olen = 4*((len + 2) / 3); /* 3-byte blocks to 4-byte */

    if (olen < len)
        return std::string(); /* integer overflow */

    std::string outStr;
    outStr.resize(olen);
    out = (unsigned char*)&outStr[0];

    end = src + len;
    in = src;
    pos = out;
    while (end - in >= 3) {
        *pos++ = base64_table[in[0] >> 2];
        *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)];
        *pos++ = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)];
        *pos++ = base64_table[in[2] & 0x3f];
        in += 3;
    }

    if (end - in) {
        *pos++ = base64_table[in[0] >> 2];
        if (end - in == 1) {
            *pos++ = base64_table[(in[0] & 0x03) << 4];
            *pos++ = '=';
        }
        else {
            *pos++ = base64_table[((in[0] & 0x03) << 4) |
                (in[1] >> 4)];
            *pos++ = base64_table[(in[1] & 0x0f) << 2];
        }
        *pos++ = '=';
    }

    return outStr;
}

দ্রুততম ব্যবস্থাপক: এখানে ডিকোডিংয়ের ফলাফল রয়েছে এবং আমি স্বীকার করতে হবে যে আমি কিছুটা অবাক হয়েছি:

polfosol                    45.2335
wikibooks_org_c             74.7347
apache                      77.1438
libb64                      100.332
gnome                       114.511
manuelmartinez              126.579
elegantdice                 138.514
daedalusalpha               151.561
jounimalinen                206.163
arduino                     335.95
wikibooks_org_cpp           350.437
CppCodec                    526.187
internetsoftwareconsortium  862.833
libcurl                     1280.27
LihO                        1852.4
adp_gmbh                    1934.43
user152949                  5332.87

সি ++ তে বেস 64৪ ডিকোড স্নিপেট থেকে পোলফসলের স্নিপেট প্রায় 2x এর একটি ফ্যাক্টর দ্বারা দ্রুততম।

সম্পূর্ণতার জন্য কোড এখানে:

static const int B64index[256] = { 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 62, 63, 62, 62, 63, 52, 53, 54, 55,
56, 57, 58, 59, 60, 61,  0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  3,  4,  5,  6,
7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,  0,
0,  0,  0, 63,  0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 };

std::string b64decode(const void* data, const size_t len)
{
    unsigned char* p = (unsigned char*)data;
    int pad = len > 0 && (len % 4 || p[len - 1] == '=');
    const size_t L = ((len + 3) / 4 - pad) * 4;
    std::string str(L / 4 * 3 + pad, '\0');

    for (size_t i = 0, j = 0; i < L; i += 4)
    {
        int n = B64index[p[i]] << 18 | B64index[p[i + 1]] << 12 | B64index[p[i + 2]] << 6 | B64index[p[i + 3]];
        str[j++] = n >> 16;
        str[j++] = n >> 8 & 0xFF;
        str[j++] = n & 0xFF;
    }
    if (pad)
    {
        int n = B64index[p[L]] << 18 | B64index[p[L + 1]] << 12;
        str[str.size() - 1] = n >> 16;

        if (len > L + 2 && p[L + 2] != '=')
        {
            n |= B64index[p[L + 2]] << 6;
            str.push_back(n >> 8 & 0xFF);
        }
    }
    return str;
}
— GaspardP
সূত্র
18
আমি সত্যিই ভাবি না যে স্টাডি :: স্ট্রিং এবং আপনার ব্যবহৃত বাকী কাজগুলি এএনএসআই সি এর অংশ, প্রশ্নটি সি কোডের জন্য জিজ্ঞাসা করছে, এবং সি ট্যাগ করেছে, সি ++-এ সর্বাধিক আপত্তিকর উত্তর পেয়েছে।
— এসএফ
4
নিজেকে উদ্ধৃত করে "আমি নিজেকে সি অ্যালগরিদমে সীমাবদ্ধ রাখিনি - যদি একটি বাস্তবায়ন সি ++ এ ভাল সম্পাদন করে তবে সহজেই সিটিতে ব্যাকপোর্ট করা যায়"। অন্য একটি char* outStrপ্যারামিটার যুক্ত করুন এবং std::stringযদি আপনি চান তবে এটি ফিরিয়ে দেওয়ার পরিবর্তে সেই বাফারটিতে লিখুন এটি করা তুচ্ছ। আমি এটি পোস্ট করার আগে ইতিমধ্যে এখানে upvotes সহ দুটি সি ++ উত্তর ছিল।
— গ্যাসপার্ডপি
এক একটি সমাধান দুটি স্থান থেকে কোড নেওয়া আমি সি জন্য সি এবং polfosol এর সমাধান জন্য ++, Apache সংস্করণ চয়ন করবে করেও উভয় ডিকোডিং এবং এনকোডিং জন্য ভাল কাজ করে চায়
— DaedalusAlpha
@ গ্যাসপার্ডপি কি জলির এনকোডিংয়ে পোলফসলের ডিকোডিং ব্যবহার করা যেতে পারে?
— স্যাম থমাস
33

তবে আপনি এটি ওপেনসেলেও করতে পারেন ( openssl encকমান্ড এটি করে ....), BIO_f_base64()ফাংশনটি দেখুন

— পাইওটার লেসনিকি
সূত্র
দেখে মনে হচ্ছে যে ওপি ইতিমধ্যে অন্য কোনও কারণে ওপেনএসএসএল ব্যবহার করছে, সুতরাং এটি সম্ভবত এটি সবচেয়ে ভাল উপায়।
— joshk0
18

ওপেনএসএসএল ব্যবহার করে আমার সমাধান এখানে।

/* A BASE-64 ENCODER AND DECODER USING OPENSSL */
#include <openssl/pem.h>
#include <string.h> //Only needed for strlen().

char *base64encode (const void *b64_encode_this, int encode_this_many_bytes){
    BIO *b64_bio, *mem_bio;      //Declares two OpenSSL BIOs: a base64 filter and a memory BIO.
    BUF_MEM *mem_bio_mem_ptr;    //Pointer to a "memory BIO" structure holding our base64 data.
    b64_bio = BIO_new(BIO_f_base64());                      //Initialize our base64 filter BIO.
    mem_bio = BIO_new(BIO_s_mem());                           //Initialize our memory sink BIO.
    BIO_push(b64_bio, mem_bio);            //Link the BIOs by creating a filter-sink BIO chain.
    BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL);  //No newlines every 64 characters or less.
    BIO_write(b64_bio, b64_encode_this, encode_this_many_bytes); //Records base64 encoded data.
    BIO_flush(b64_bio);   //Flush data.  Necessary for b64 encoding, because of pad characters.
    BIO_get_mem_ptr(mem_bio, &mem_bio_mem_ptr);  //Store address of mem_bio's memory structure.
    BIO_set_close(mem_bio, BIO_NOCLOSE);   //Permit access to mem_ptr after BIOs are destroyed.
    BIO_free_all(b64_bio);  //Destroys all BIOs in chain, starting with b64 (i.e. the 1st one).
    BUF_MEM_grow(mem_bio_mem_ptr, (*mem_bio_mem_ptr).length + 1);   //Makes space for end null.
    (*mem_bio_mem_ptr).data[(*mem_bio_mem_ptr).length] = '\0';  //Adds null-terminator to tail.
    return (*mem_bio_mem_ptr).data; //Returns base-64 encoded data. (See: "buf_mem_st" struct).
}

char *base64decode (const void *b64_decode_this, int decode_this_many_bytes){
    BIO *b64_bio, *mem_bio;      //Declares two OpenSSL BIOs: a base64 filter and a memory BIO.
    char *base64_decoded = calloc( (decode_this_many_bytes*3)/4+1, sizeof(char) ); //+1 = null.
    b64_bio = BIO_new(BIO_f_base64());                      //Initialize our base64 filter BIO.
    mem_bio = BIO_new(BIO_s_mem());                         //Initialize our memory source BIO.
    BIO_write(mem_bio, b64_decode_this, decode_this_many_bytes); //Base64 data saved in source.
    BIO_push(b64_bio, mem_bio);          //Link the BIOs by creating a filter-source BIO chain.
    BIO_set_flags(b64_bio, BIO_FLAGS_BASE64_NO_NL);          //Don't require trailing newlines.
    int decoded_byte_index = 0;   //Index where the next base64_decoded byte should be written.
    while ( 0 < BIO_read(b64_bio, base64_decoded+decoded_byte_index, 1) ){ //Read byte-by-byte.
        decoded_byte_index++; //Increment the index until read of BIO decoded data is complete.
    } //Once we're done reading decoded data, BIO_read returns -1 even though there's no error.
    BIO_free_all(b64_bio);  //Destroys all BIOs in chain, starting with b64 (i.e. the 1st one).
    return base64_decoded;        //Returns base-64 decoded data with trailing null terminator.
}

/*Here's one way to base64 encode/decode using the base64encode() and base64decode functions.*/
int main(void){
    char data_to_encode[] = "Base64 encode this string!";  //The string we will base-64 encode.

    int bytes_to_encode = strlen(data_to_encode); //Number of bytes in string to base64 encode.
    char *base64_encoded = base64encode(data_to_encode, bytes_to_encode);   //Base-64 encoding.

    int bytes_to_decode = strlen(base64_encoded); //Number of bytes in string to base64 decode.
    char *base64_decoded = base64decode(base64_encoded, bytes_to_decode);   //Base-64 decoding.

    printf("Original character string is: %s\n", data_to_encode);  //Prints our initial string.
    printf("Base-64 encoded string is: %s\n", base64_encoded);  //Prints base64 encoded string.
    printf("Base-64 decoded string is: %s\n", base64_decoded);  //Prints base64 decoded string.

    free(base64_encoded);                //Frees up the memory holding our base64 encoded data.
    free(base64_decoded);                //Frees up the memory holding our base64 decoded data.
}
— schulwitz
সূত্র
2
"একটি নাল-টার্মিনেটর যুক্ত করুন" রেখায় আমি একটি অ্যাড্রেসসানাইটিজার ত্রুটি পেয়েছি যে লিখনটি 1 বাইট দ্বারা স্তূপকে উপচে ফেলেছে।
— বিপারপারার
ধন্যবাদ, কোডটি বিজ্ঞাপন হিসাবে কাজ করছে কিনা তা নিশ্চিত করার জন্য আমি এলোমেলো বাইটের এলোমেলো আকারের স্ট্রিংগুলির সাথে বিস্তৃত পরীক্ষার পাশাপাশি ত্রুটিটি সংশোধন করেছি। :)
— স্কুলউইটস
1
চমৎকার! আমি এটি দিয়ে সংকলিত cc -o base base.c -lssl -lcrypto । কোনও ত্রুটি নেই। এটি এই আউটপুটটি উত্পাদন করেছে: Original character string is: Base64 encode this string! Base-64 encoded string is: QmFzZTY0IGVuY29kZSB0aGlzIHN0cmluZyE= Base-64 decoded string is: Base64 encode this string!
— স্পষ্টলাইট
@ স্কুলউইটজ আমার কাছে একটি ফাইল রয়েছে যা পাইথন ব্যবহার করে স্ট্রিং হিসাবে এনকোড করা থাকে, তবে আমি যখন আপনার ফাংশনটি ব্যবহার করে স্ট্রিংটি ডিকোড করি এবং কোনও ফাইলের (সি তে) ডিকোডযুক্ত ফলাফলটি লেখার চেষ্টা করি তখন আমি একই ফাইলটি ফিরে পাই না। এনকোডেড স্ট্রিংটি সঠিক। `` `কনট স্বাক্ষরিত চর * জারফিল =" <এনকোড ফাইল> "; int main () {print_version (); ফাইল * এফপি; চর * আউট = বেস64ডেকোড (জারফাইল, স্ট্রলেন (জারফাইল)); fp = fopen ("file.jar", "wb"); যদি (fp == NULL) {printf ("ফাইল খুলতে ব্যর্থ হয়েছে"); প্রত্যাবর্তন 1; w স্বাক্ষরিত (আউট, মাপের (আউট), 1, এফপি); fclose সাথে (FP); বিনামূল্যে আউট); প্রত্যাবর্তন 0; } `` `
— স্যাম টমাস
1
@ স্যাম টোমাস স্ট্রেন ব্যবহার করে আমার উদাহরণটিতে কাজ করে কারণ আমি একটি স্ট্রিং তৈরি করেছি যেখানে কেবলমাত্র একটি নাল টার্মিনেটর বিদ্যমান (এবং এটি স্ট্রিংয়ের শেষে) at দেখুন: টিউটোরিয়ালপয়েন্ট /cprogramming/c_strings.htm স্ট্রলেন সহ জারফাইলে পড়া ব্যর্থ হবে, কারণ সম্ভবত বাইনারি ফাইলের মাঝখানে একটি নাল টার্মিনেটর উপস্থিত রয়েছে, বাইটস_টো_ডেকোড মানটি বিশৃঙ্খলা করে। দেখুন: stackoverflow.com/questions/24596189/... আপনার ফাইলের আকারের অন্যভাবে খুঁজুন: stackoverflow.com/questions/238603/...
— schulwitz
18

গ্লিবের বেস 64 টি এনকোডিংয়ের জন্য ফাংশন রয়েছে: https://developer.gnome.org/glib/stable/glib-Base64-Encoding.html

— stesch
সূত্র
7
যদিও এই লিঙ্কটি প্রশ্নের উত্তর দিতে পারে, উত্তরের প্রয়োজনীয় অংশগুলি এখানে অন্তর্ভুক্ত করা এবং রেফারেন্সের জন্য লিঙ্কটি সরবরাহ করা ভাল। লিঙ্কযুক্ত পৃষ্ঠাগুলি পরিবর্তিত হলে লিঙ্ক-শুধুমাত্র উত্তরগুলি অবৈধ হতে পারে।
— সমস্ত শ্রমিক
16

libb64 এর সি এবং সি ++ উভয়ই API রয়েছে। এটি হালকা ওজন এবং সম্ভবত সর্বজনীনভাবে উপলব্ধ কার্যকর প্রয়োগ implementation এটি একটি ডেডিকেটেড স্ট্যান্ড-অলোন বেস 64 এনকোডিং লাইব্রেরি, যা ওপেনএসএসএল বা গ্লিবের মতো বৃহত্তর লাইব্রেরি ব্যবহার করে যে সমস্ত অন্যান্য জিনিসপত্রের প্রয়োজন না পড়লে আপনার পক্ষে যদি ভাল লাগে তবে তা ভাল।

— ড্যান ছাঁচনির্মাণ
সূত্র
5
Libb64- এ নোট করুন: বুফার্সিজিকে একটি মেক ফাইলে সংজ্ঞায়িত করা হয়েছে, সুতরাং আপনি যদি মেক / cmake ব্যবহার না করেন তবে এটি সঙ্কলনের জন্য আপনাকে হেডার ফাইলগুলিতে ম্যানুয়ালি এটি সংজ্ঞায়িত করতে হবে। ওয়ার্কস / সংক্ষেপে VS2012 পরীক্ষা করা হয়েছে
— টম
3
যেমনটি টম বলেছেন: #define BUFFERSIZE 16777216আপনার যদি আরও ছোট বাফার প্রয়োজন হয় তবে আপনি 65536 এ প্রতিস্থাপন করতে পারেন।
— jyz
1
সতর্ক থাকুন! ডিবাগিংয়ের এক ঘন্টা পরে আমি বুঝতে পারলাম যে libb64 ধরে নিয়েছে যে charটার্গেট সিস্টেমে স্বাক্ষরিত ... এটি একটি সমস্যা যেহেতু base64_decode_valueএকটি নেতিবাচক সংখ্যা যা চরে পরে দেওয়া হবে তা ফেরত দিতে পারে।
— নয়ার
নোট উত্সফোর্স বাস্তবায়ন নতুন লাইনের যোগ করে যা সর্বজনীন সমর্থিত নয়। গিথুবে বুওলজিকসের একটি কাঁটাচামচ সেগুলি সরিয়ে দেয় এবং আমি আপনার চূড়ান্ত দরকারী সন্ধানের উপর ভিত্তি করে একটি পুল অনুরোধ উত্পন্ন করেছি , @ নইয়ার।
— ক্ষারত্ব
যদিও এই লিঙ্কটি প্রশ্নের উত্তর দিতে পারে, উত্তরের প্রয়োজনীয় অংশগুলি এখানে অন্তর্ভুক্ত করা এবং রেফারেন্সের জন্য লিঙ্কটি সরবরাহ করা ভাল। লিঙ্কযুক্ত পৃষ্ঠাগুলি পরিবর্তিত হলে লিঙ্ক-শুধুমাত্র উত্তরগুলি অবৈধ হতে পারে।
— সমস্ত কর্মী
14

জিএনইউ কোর্টিলগুলিতে এটি লাইব / বেস 64 রয়েছে। এটি সামান্য ফুলে উঠেছে তবে EBCDIC এর মতো স্টাফ নিয়ে কাজ করে। আপনি নিজের মতো করে খেলতেও পারেন, যেমন,

char base64_digit (n) unsigned n; {
  if (n < 10) return n - '0';
  else if (n < 10 + 26) return n - 'a';
  else if (n < 10 + 26 + 26) return n - 'A';
  else assert(0);
  return 0;
}

unsigned char base64_decode_digit(char c) {
  switch (c) {
    case '=' : return 62;
    case '.' : return 63;
    default  :
      if (isdigit(c)) return c - '0';
      else if (islower(c)) return c - 'a' + 10;
      else if (isupper(c)) return c - 'A' + 10 + 26;
      else assert(0);
  }
  return 0xff;
}

unsigned base64_decode(char *s) {
  char *p;
  unsigned n = 0;

  for (p = s; *p; p++)
    n = 64 * n + base64_decode_digit(*p);

  return n;
}

এই উপস্থাপক দ্বারা সমস্ত ব্যক্তিকে জানুন যে "কোনও মান প্রয়োগের" সাথে আপনার নিজেরাই "নিজেকে ঘিরে খেলা" বিভ্রান্ত করা উচিত নয়। Yeesh।

— নরম্যান রামসে
সূত্র
3
এছাড়াও, '+'62 এর এবং '/'পিএম বেস 64 এ 63 হিসাবে রয়েছে ওপি দ্বারা জিজ্ঞাসা করা হয়েছে। এখানে বেস 64 এনকোডিং ভেরিয়েন্টগুলির একটি তালিকা রয়েছে । আপনি ব্যবহার করা অক্ষরের ক্রম সহ একটি বেস 64 এনকোডিং বৈকল্পিক দেখতে পাচ্ছি না। তবে অ্যালগরিদমের পিছনে গণিতটি সঠিক।
— প্যাট্রিক
2
যেমনটি ইতিমধ্যে বলেছে: সাবধান হন এই অ্যালগরিদম সাধারণ বেস 64 এর সাথে সামঞ্জস্যপূর্ণ নয়
— সেরবার
এনকোডিং সম্পর্কে কী?
— জেরেমিয়া
14

আমার স্টাডি :: স্ট্রিংয়ে কাজ করে সি ++ বাস্তবায়ন প্রয়োজন । কোনও উত্তরই আমার চাহিদা মেটাতে পারে নি, এনকোডিং এবং ডিকোডিংয়ের জন্য আমার সাধারণ দ্বি-কার্যকারিতা সমাধানের প্রয়োজন ছিল, তবে আমি নিজের কোডটি লিখতে খুব অলস ছিলাম, তাই আমি এটি পেয়েছি:

http://www.adp-gmbh.ch/cpp/common/base64.html

কোডের জন্য ক্রেডিট রেনে নিনফেনিগারে যায়।

সাইটটি নীচে যাওয়ার ক্ষেত্রে নীচের কোডটি দেওয়া:

base64.cpp

/* 
   base64.cpp and base64.h

   Copyright (C) 2004-2008 René Nyffenegger

   This source code is provided 'as-is', without any express or implied
   warranty. In no event will the author be held liable for any damages
   arising from the use of this software.

   Permission is granted to anyone to use this software for any purpose,
   including commercial applications, and to alter it and redistribute it
   freely, subject to the following restrictions:

   1. The origin of this source code must not be misrepresented; you must not
      claim that you wrote the original source code. If you use this source code
      in a product, an acknowledgment in the product documentation would be
      appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and must not be
      misrepresented as being the original source code.

   3. This notice may not be removed or altered from any source distribution.

   René Nyffenegger rene.nyffenegger@adp-gmbh.ch

*/

#include "base64.h"
#include <iostream>

static const std::string base64_chars = 
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz"
             "0123456789+/";


static inline bool is_base64(unsigned char c) {
  return (isalnum(c) || (c == '+') || (c == '/'));
}

std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];

  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;

      for(i = 0; (i <4) ; i++)
        ret += base64_chars[char_array_4[i]];
      i = 0;
    }
  }

  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';

    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;

    for (j = 0; (j < i + 1); j++)
      ret += base64_chars[char_array_4[j]];

    while((i++ < 3))
      ret += '=';

  }

  return ret;

}

std::string base64_decode(std::string const& encoded_string) {
  int in_len = encoded_string.size();
  int i = 0;
  int j = 0;
  int in_ = 0;
  unsigned char char_array_4[4], char_array_3[3];
  std::string ret;

  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
    char_array_4[i++] = encoded_string[in_]; in_++;
    if (i ==4) {
      for (i = 0; i <4; i++)
        char_array_4[i] = base64_chars.find(char_array_4[i]);

      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

      for (i = 0; (i < 3); i++)
        ret += char_array_3[i];
      i = 0;
    }
  }

  if (i) {
    for (j = i; j <4; j++)
      char_array_4[j] = 0;

    for (j = 0; j <4; j++)
      char_array_4[j] = base64_chars.find(char_array_4[j]);

    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
  }

  return ret;
}

base64.h

#include <string>

std::string base64_encode(unsigned char const* , unsigned int len);
std::string base64_decode(std::string const& s);

ব্যবহার

const std::string s = "test";
std::string encoded = base64_encode(reinterpret_cast<const unsigned char*>(s.c_str()), s.length());
  std::string decoded = base64_decode(encoded);
— Wookie88
সূত্র
9

আমি বছরের পর বছর ধরে এই ডিকোডারটি ব্যবহার করছি ...

    static const char  table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    static const int   BASE64_INPUT_SIZE = 57;

    BOOL isbase64(char c)
    {
       return c && strchr(table, c) != NULL;
    }

    inline char value(char c)
    {
       const char *p = strchr(table, c);
       if(p) {
          return p-table;
       } else {
          return 0;
       }
    }

    int UnBase64(unsigned char *dest, const unsigned char *src, int srclen)
    {
       *dest = 0;
       if(*src == 0) 
       {
          return 0;
       }
       unsigned char *p = dest;
       do
       {

          char a = value(src[0]);
          char b = value(src[1]);
          char c = value(src[2]);
          char d = value(src[3]);
          *p++ = (a << 2) | (b >> 4);
          *p++ = (b << 4) | (c >> 2);
          *p++ = (c << 6) | d;
          if(!isbase64(src[1])) 
          {
             p -= 2;
             break;
          } 
          else if(!isbase64(src[2])) 
          {
             p -= 2;
             break;
          } 
          else if(!isbase64(src[3])) 
          {
             p--;
             break;
          }
          src += 4;
          while(*src && (*src == 13 || *src == 10)) src++;
       }
       while(srclen-= 4);
       *p = 0;
       return p-dest;
    }
— LarryF
সূত্র
* ভাগ্য = 0 কী; শুরুতে?
— টিম
1
এটি একটি খুব সহজ অপারেশন যা কলটি কল করার আগে কলার যদি তা না করে তবে ডাস্ট বাফারটি NULL তে সেট করা নিশ্চিত করে এবং সম্ভবত ডিকোড ব্যর্থ হলে ফিরে আসা বাফারটি দৈর্ঘ্যের দৈর্ঘ্য হবে। আমি বলিনি যে আমি এই রুটিনটিকে ডিবাগ, ট্রেস, এবং প্রোফাইল করেছি, এটি কেবল বছরের পর বছর ধরে আমি ব্যবহার করে আসছি। :) আমি এখন এটি তাকান, এটি সত্যিই সেখানে থাকার প্রয়োজন হয় না, তাই, আমরা কেন এটি "পাঠকের অনুশীলন" বলি না? হেই .. সম্ভবত আমি এটি সম্পাদনা করব। এটা ইশারা জন্য ধন্যবাদ!
— ল্যারিএফ
3
আপনার UnBase64ফাংশনটি ডেস্ট বাফারের পরে মেমরির সাথে আপস করতে পারে, যদি সেই বাফারটি সঠিক আকারটি বেস 64 এনকোড স্ট্রিংটি ডিকোড করার জন্য প্রয়োজন। উদাহরণস্বরূপ সরল ক্ষেত্রে নিন যেখানে আপনি নীচের বেসটি 64 এনকোড স্ট্রিং "বিকিউ ==" কে একক বিওয়াইটিইতে ডিকোড করার চেষ্টা করছেন অর্থাত্ unsigned char Result = 0; UnBase64(&Result, "BQ==", 4); এটি স্ট্যাকটিকে দূষিত করবে!
— মাইক ডাইনেস্কু
3
হ্যাঁ, আমাদের অ্যাপ্লিকেশনটিতে বাজে বাগের কারণে। সুপারিশ করবেন না।
— হ্যারাল্ড মাশসেন
হাই ল্যারি, আপনাকে কোড ভাগ করে নেওয়ার জন্য ধন্যবাদ। এটা খুব দরকারী!
— ফেডেরিকো
4

লোকেরা যদি সি ++ সমাধানের প্রয়োজন হয় তবে আমি এই ওপেনএসএসএল সমাধানটি একসাথে রেখেছি (উভয় এনকোড এবং ডিকোডের জন্য)। আপনাকে "ক্রিপ্টো" লাইব্রেরির সাথে লিঙ্ক করতে হবে (যা ওপেনএসএসএল)। এটি ভালগ্রাইন্ডের সাথে ফাঁসের জন্য পরীক্ষা করা হয়েছে (যদিও আপনি এটি কিছুটা আরও ভাল করার জন্য কিছু অতিরিক্ত ত্রুটি পরীক্ষা করার কোড যুক্ত করতে পারেন - আমি জানি কমপক্ষে লেখার ফাংশনটি রিটার্ন মানটির জন্য যাচাই করা উচিত)।

#include <openssl/bio.h>
#include <openssl/evp.h>
#include <stdlib.h>

string base64_encode( const string &str ){

    BIO *base64_filter = BIO_new( BIO_f_base64() );
    BIO_set_flags( base64_filter, BIO_FLAGS_BASE64_NO_NL );

    BIO *bio = BIO_new( BIO_s_mem() );
    BIO_set_flags( bio, BIO_FLAGS_BASE64_NO_NL );

    bio = BIO_push( base64_filter, bio );

    BIO_write( bio, str.c_str(), str.length() );

    BIO_flush( bio );

    char *new_data;

    long bytes_written = BIO_get_mem_data( bio, &new_data );

    string result( new_data, bytes_written );
    BIO_free_all( bio );

    return result;

}



string base64_decode( const string &str ){

    BIO *bio, *base64_filter, *bio_out;
    char inbuf[512];
    int inlen;
    base64_filter = BIO_new( BIO_f_base64() );
    BIO_set_flags( base64_filter, BIO_FLAGS_BASE64_NO_NL );

    bio = BIO_new_mem_buf( (void*)str.c_str(), str.length() );

    bio = BIO_push( base64_filter, bio );

    bio_out = BIO_new( BIO_s_mem() );

    while( (inlen = BIO_read(bio, inbuf, 512)) > 0 ){
        BIO_write( bio_out, inbuf, inlen );
    }

    BIO_flush( bio_out );

    char *new_data;
    long bytes_written = BIO_get_mem_data( bio_out, &new_data );

    string result( new_data, bytes_written );

    BIO_free_all( bio );
    BIO_free_all( bio_out );

    return result;

}
— Homer6
সূত্র
BIO_free_all এর মাথা নির্দিষ্ট করতে হবে - আপনার বায়ো চেইনের লেজ নয় - (যেমন বেস 64_ ফিল্টার)। আপনার বর্তমান বাস্তবায়নের একটি মেমরি ফুটো রয়েছে।
— স্কুলউইটজ
@ স্কুলউইটজ কোন লাইনে ফুটো হয়েছে? বায়ো_ফ্রি_ সমস্ত পুরো চেইনকে মুক্ত করে।
— হোমার 6
4

আমি সি ++ এর সাথে ব্যবহারের জন্য একটি লিখেছি, এটি খুব দ্রুত, স্ট্রিমের সাথে কাজ করে, বিনামূল্যে এবং মুক্ত উত্স:

https://tmplusplus.svn.sourceforge.net/svnroot/tmplusplus/trunk/src/

এটি আপনার উদ্দেশ্য অনুসারে নির্দ্বিধায় ব্যবহার করুন।

সম্পাদনা করুন: অনুরোধ অনুসারে কোড ইনলাইন যুক্ত হয়েছে।

এনকোডিং এবং ডিকোডিংয়ের জন্য অনুসন্ধান সারণী ব্যবহার করে পারফরম্যান্স বুস্টটি অর্জিত হয়। _UINT8একটি হল unsigned charসবচেয়ে ওএস এর উপর।

/** Static Base64 character encoding lookup table */
const char CBase64::encodeCharacterTable[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/** Static Base64 character decoding lookup table */
const char CBase64::decodeCharacterTable[256] = {
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
    ,-1,62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21
    ,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
    ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
    -1,-1,-1}; 

/*!
\brief Encodes binary data to base 64 character data
\param in The data to encode
\param out The encoded data as characters
*/
void CBase64::Encode(std::istream &in, std::ostringstream &out)
{
    char buff1[3];
    char buff2[4];
    _UINT8 i=0, j;
    while(in.readsome(&buff1[i++], 1))
        if (i==3)
        {
            out << encodeCharacterTable[(buff1[0] & 0xfc) >> 2];
            out << encodeCharacterTable[((buff1[0] & 0x03) << 4) + ((buff1[1] & 0xf0) >> 4)];
            out << encodeCharacterTable[((buff1[1] & 0x0f) << 2) + ((buff1[2] & 0xc0) >> 6)];
            out << encodeCharacterTable[buff1[2] & 0x3f];
            i=0;
        }

    if (--i)
    {
        for(j=i;j<3;j++) buff1[j] = '\0';

        buff2[0] = (buff1[0] & 0xfc) >> 2;
        buff2[1] = ((buff1[0] & 0x03) << 4) + ((buff1[1] & 0xf0) >> 4);
        buff2[2] = ((buff1[1] & 0x0f) << 2) + ((buff1[2] & 0xc0) >> 6);
        buff2[3] = buff1[2] & 0x3f;

        for (j=0;j<(i+1);j++) out << encodeCharacterTable[buff2[j]];

        while(i++<3) out << '=';
    }

}

/*!
\brief Decodes base 64 character data to binary data
\param in The character data to decode
\param out The decoded data
*/
void CBase64::Decode(std::istringstream &in, std::ostream &out)
{
    char buff1[4];
    char buff2[4];
    _UINT8 i=0, j;

    while(in.readsome(&buff2[i], 1) && buff2[i] != '=')
    {
        if (++i==4)
        {
            for (i=0;i!=4;i++)
                buff2[i] = decodeCharacterTable[buff2[i]];

            out << (char)((buff2[0] << 2) + ((buff2[1] & 0x30) >> 4));
            out << (char)(((buff2[1] & 0xf) << 4) + ((buff2[2] & 0x3c) >> 2));
            out << (char)(((buff2[2] & 0x3) << 6) + buff2[3]);

            i=0;
        }
    }

    if (i) 
    {
        for (j=i;j<4;j++) buff2[j] = '\0';
        for (j=0;j<4;j++) buff2[j] = decodeCharacterTable[buff2[j]];

        buff1[0] = (buff2[0] << 2) + ((buff2[1] & 0x30) >> 4);
        buff1[1] = ((buff2[1] & 0xf) << 4) + ((buff2[2] & 0x3c) >> 2);
        buff1[2] = ((buff2[2] & 0x3) << 6) + buff2[3];

        for (j=0;j<(i-1); j++) out << (char)buff1[j];
    }
}
1
লিঙ্কযুক্ত ব্লগটি আর সেই URL এ উপস্থিত নেই বলে মনে হয়।
— হাল্কহোল্ডেন
@ হুল্কহোল্ডেন এটি এখনও এখানে পাওয়া যায় tmplusplus.svn.sourceforge.net/svnroot/tmplusplus/trunk/src
@ সিপিবার্নজ আমি এখনই ইনলাইন উদাহরণ যুক্ত করেছি এবং কেন এটি দ্রুত, একটি মন্তব্য।
2

রাইস্টের কোডটিতে সামান্য উন্নতি (যিনি সর্বাধিক ভোট পেয়েছিলেন) ডায়নামিকভাবে বরাদ্দকৃত ডিকোডিং টেবিলটি ব্যবহার না করে বরং স্থিতিশীল কনস্টাম পূর্ববর্তী টেবিলটি ব্যবহার করা। এটি টেবিলের পয়েন্টার এবং ইনিশিয়ালেশনের ব্যবহারকে বাদ দেয় এবং মেমরি ফাঁসকে এড়িয়ে যায় যদি কেউ বেস 64_cleanup () দিয়ে, ফ্রি (ডিকোডিং_ টেবিল) কল করার পরে, ডিকোডিং টেবিলটি পরিষ্কার করতে ভুলে যায় তবে তার একটি হওয়া উচিত ডিকোডিং_ট্যাবল = এনএলএল, অন্যথায় দুর্ঘটনাবশত বেস64ু_সেকানআপের পরে বেস6464decode কল করা () ক্র্যাশ হয়ে যাবে বা নির্ধারিত আচরণের কারণ ঘটবে)। আর একটি সমাধান হতে পারে স্ট্যান্ড :: ইউনিক_পিটার ব্যবহার করা ... তবে আমি স্ট্যাকের উপর কেবল কনট চর [256] রাখার দ্বারা সন্তুষ্ট এবং পয়েন্টারগুলি পুরোপুরি ব্যবহার করা এড়ানো - কোডটি এইভাবে পরিষ্কার এবং সংক্ষিপ্ত দেখায়।

ডিকোডিং টেবিলটি নিম্নরূপে গণনা করা হয়েছে:

const char encoding_table[] = { 
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
    'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
    'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
    'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
    'w', 'x', 'y', 'z', '0', '1', '2', '3',
    '4', '5', '6', '7', '8', '9', '+', '/' };

unsigned char decoding_table[256];

for (int i = 0; i < 256; i++)
    decoding_table[i] = '\0';

for (int i = 0; i < 64; i++)
    decoding_table[(unsigned char)encoding_table[i]] = i;

for (int i = 0; i < 256; i++)
    cout << "0x" << (int(decoding_table[i]) < 16 ? "0" : "") << hex << int(decoding_table[i]) << (i != 255 ? "," : "") << ((i+1) % 16 == 0 ? '\n' : '\0');

cin.ignore();

এবং আমি যে সংশোধিত কোডটি ব্যবহার করছি তা হ'ল:

        static const char encoding_table[] = { 
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
            'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
            'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
            'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
            'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
            'w', 'x', 'y', 'z', '0', '1', '2', '3',
            '4', '5', '6', '7', '8', '9', '+', '/' };

        static const unsigned char decoding_table[256] = {
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
            0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
            0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
            0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

        char* base64_encode(const unsigned char *data, size_t input_length, size_t &output_length) {

            const int mod_table[] = { 0, 2, 1 };

            output_length = 4 * ((input_length + 2) / 3);

            char *encoded_data = (char*)malloc(output_length);

            if (encoded_data == nullptr)
                return nullptr;

            for (int i = 0, j = 0; i < input_length;) {

                uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0;
                uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0;
                uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0;

                uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;

                encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
                encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
                encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
                encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];

            }

            for (int i = 0; i < mod_table[input_length % 3]; i++)
                encoded_data[output_length - 1 - i] = '=';

            return encoded_data;

        };

        unsigned char* base64_decode(const char *data, size_t input_length, size_t &output_length) {        

            if (input_length % 4 != 0)
                return nullptr;

            output_length = input_length / 4 * 3;

            if (data[input_length - 1] == '=') (output_length)--;
            if (data[input_length - 2] == '=') (output_length)--;

            unsigned char* decoded_data = (unsigned char*)malloc(output_length);

            if (decoded_data == nullptr)
                return nullptr;

            for (int i = 0, j = 0; i < input_length;) {

                uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
                uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
                uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
                uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];

                uint32_t triple = (sextet_a << 3 * 6)
                    + (sextet_b << 2 * 6)
                    + (sextet_c << 1 * 6)
                    + (sextet_d << 0 * 6);

                if (j < output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
                if (j < output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
                if (j < output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;

            }

            return decoded_data;

        };
— OGCJN
সূত্র
1

এটি একটি ডিকোডার যা বিশেষত একটি পুটচার ফাংশনে সরাসরি লিখে বাফারের প্রয়োজনীয়তা এড়াতে লেখা হয়। এটি উইকিবুকের বাস্তবায়নের উপর ভিত্তি করে https://en.wikibooks.org/wiki/Algorithm_Implementation/Miscellaneous/Base64#C

উপরের অন্যান্য বিকল্পগুলির মতো এটি ব্যবহার করা সহজ নয়। তবে এটি এম্বেড থাকা সিস্টেমে ব্যবহার করা যেতে পারে, যেখানে আপনি ফলস্বর ভিত্তি বেস 64৪ ডেটাগুড়ি স্ট্রিংয়ের জন্য অন্য কোনও বড় বাফার বরাদ্দ না করে একটি বড় ফাইল ডাম্প করতে চান। (এটি অত্যন্ত দুঃখের বিষয় যে ডেটাউরি আপনাকে ফাইলের নাম নির্দিষ্ট করতে দেয় না)।

void datauriBase64EncodeBufferless(int (*putchar_fcptr)(int), const char* type_strptr, const void* data_buf, const size_t dataLength)
{
  const char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  const uint8_t *data = (const uint8_t *)data_buf;
  size_t x = 0;
  uint32_t n = 0;
  int padCount = dataLength % 3;
  uint8_t n0, n1, n2, n3;

  size_t outcount = 0;
  size_t line = 0;

  putchar_fcptr((int)'d');
  putchar_fcptr((int)'a');
  putchar_fcptr((int)'t');
  putchar_fcptr((int)'a');
  putchar_fcptr((int)':');
  outcount += 5;

  while (*type_strptr != '\0')
  {
    putchar_fcptr((int)*type_strptr);
    type_strptr++;
    outcount++;
  }

  putchar_fcptr((int)';');
  putchar_fcptr((int)'b');
  putchar_fcptr((int)'a');
  putchar_fcptr((int)'s');
  putchar_fcptr((int)'e');
  putchar_fcptr((int)'6');
  putchar_fcptr((int)'4');
  putchar_fcptr((int)',');
  outcount += 8;

  /* increment over the length of the string, three characters at a time */
  for (x = 0; x < dataLength; x += 3)
  {
    /* these three 8-bit (ASCII) characters become one 24-bit number */
    n = ((uint32_t)data[x]) << 16; //parenthesis needed, compiler depending on flags can do the shifting before conversion to uint32_t, resulting to 0

    if((x+1) < dataLength)
       n += ((uint32_t)data[x+1]) << 8;//parenthesis needed, compiler depending on flags can do the shifting before conversion to uint32_t, resulting to 0

    if((x+2) < dataLength)
       n += data[x+2];

    /* this 24-bit number gets separated into four 6-bit numbers */
    n0 = (uint8_t)(n >> 18) & 63;
    n1 = (uint8_t)(n >> 12) & 63;
    n2 = (uint8_t)(n >> 6) & 63;
    n3 = (uint8_t)n & 63;

    /*
     * if we have one byte available, then its encoding is spread
     * out over two characters
     */

    putchar_fcptr((int)base64chars[n0]);
    putchar_fcptr((int)base64chars[n1]);
    outcount += 2;

    /*
     * if we have only two bytes available, then their encoding is
     * spread out over three chars
     */
    if((x+1) < dataLength)
    {
      putchar_fcptr((int)base64chars[n2]);
      outcount += 1;
    }

    /*
     * if we have all three bytes available, then their encoding is spread
     * out over four characters
     */
    if((x+2) < dataLength)
    {
      putchar_fcptr((int)base64chars[n3]);
      outcount += 1;
    }

    /* Breaking up the line so it's easier to copy and paste */
    int curr_line = (outcount/80);
    if( curr_line != line )
    {
      line = curr_line;
      putchar_fcptr((int)'\r');
      putchar_fcptr((int)'\n');
    }
  }

  /*
  * create and add padding that is required if we did not have a multiple of 3
  * number of characters available
  */
  if (padCount > 0)
  {
    for (; padCount < 3; padCount++)
    {
      putchar_fcptr((int)'=');
    }
  }

  putchar_fcptr((int)'\r');
  putchar_fcptr((int)'\n');
}

এই পরীক্ষা

#include <stdio.h>
#include <stdint.h>
#include <string.h>

int main(void)
{
  char str[] = "test";
  datauriBase64EncodeBufferless(putchar, "text/plain;charset=utf-8", str, strlen(str));
  return 0;
}

প্রত্যাশিত আউটপুট: data:text/plain;charset=utf-8;base64,dGVzdA==

— ব্রায়ান
সূত্র
1

EVP_EncodeBlockএবং EVP_DecodeBlockফাংশন এটি খুব সহজ করুন:

#include <stdio.h>
#include <stdlib.h>
#include <openssl/evp.h>

char *base64(const unsigned char *input, int length) {
  const int pl = 4*((length+2)/3);
  char *output = calloc(pl+1, 1); //+1 for the terminating null that EVP_EncodeBlock adds on
  const int ol = EVP_EncodeBlock(output, input, length);
  if (ol != pl) { fprintf(stderr, "Whoops, encode predicted %d but we got %d\n", pl, ol); }
  return output;
}

unsigned char *decode64(const char *input, int length) {
  const int pl = 3*length/4;
  unsigned char *output = calloc(pl+1, 1);
  const int ol = EVP_DecodeBlock(output, input, length);
  if (pl != ol) { fprintf(stderr, "Whoops, decode predicted %d but we got %d\n", pl, ol); }
  return output;
}
— mtrw
সূত্র
0

এই সমাধানটি স্কুলউইজের উত্তর (ওপেনএসএসএল ব্যবহার করে এনকোডিং / ডিকোডিং) এর উপর ভিত্তি করে তৈরি হয়েছে তবে এটি সি ++ এর জন্য রয়েছে (ভাল, মূল প্রশ্নটি সি সম্পর্কে ছিল, তবে ইতিমধ্যে এখানে আরও একটি সি ++ উত্তর রয়েছে) এবং এটি ত্রুটি পরীক্ষা করে ব্যবহার করে (সুতরাং এটি ব্যবহার করা নিরাপদ) :

#include <openssl/bio.h>

std::string base64_encode(const std::string &input)
{
    BIO *p_bio_b64 = nullptr;
    BIO *p_bio_mem = nullptr;

    try
    {
        // make chain: p_bio_b64 <--> p_bio_mem
        p_bio_b64 = BIO_new(BIO_f_base64());
        if (!p_bio_b64) { throw std::runtime_error("BIO_new failed"); }
        BIO_set_flags(p_bio_b64, BIO_FLAGS_BASE64_NO_NL); //No newlines every 64 characters or less

        p_bio_mem = BIO_new(BIO_s_mem());
        if (!p_bio_mem) { throw std::runtime_error("BIO_new failed"); }
        BIO_push(p_bio_b64, p_bio_mem);

        // write input to chain
        // write sequence: input -->> p_bio_b64 -->> p_bio_mem
        if (BIO_write(p_bio_b64, input.c_str(), input.size()) <= 0)
            { throw std::runtime_error("BIO_write failed"); }

        if (BIO_flush(p_bio_b64) <= 0)
            { throw std::runtime_error("BIO_flush failed"); }

        // get result
        char *p_encoded_data = nullptr;
        auto  encoded_len    = BIO_get_mem_data(p_bio_mem, &p_encoded_data);
        if (!p_encoded_data) { throw std::runtime_error("BIO_get_mem_data failed"); }

        std::string result(p_encoded_data, encoded_len);

        // clean
        BIO_free_all(p_bio_b64);

        return result;
    }
    catch (...)
    {
        if (p_bio_b64) { BIO_free_all(p_bio_b64); }
        throw;
    }
}

std::string base64_decode(const std::string &input)
{
    BIO *p_bio_mem = nullptr;
    BIO *p_bio_b64 = nullptr;

    try
    {
        // make chain: p_bio_b64 <--> p_bio_mem
        p_bio_b64 = BIO_new(BIO_f_base64());
        if (!p_bio_b64) { throw std::runtime_error("BIO_new failed"); }
        BIO_set_flags(p_bio_b64, BIO_FLAGS_BASE64_NO_NL); //Don't require trailing newlines

        p_bio_mem = BIO_new_mem_buf((void*)input.c_str(), input.length());
        if (!p_bio_mem) { throw std::runtime_error("BIO_new failed"); }
        BIO_push(p_bio_b64, p_bio_mem);

        // read result from chain
        // read sequence (reverse to write): buf <<-- p_bio_b64 <<-- p_bio_mem
        std::vector<char> buf((input.size()*3/4)+1);
        std::string result;
        for (;;)
        {
            auto nread = BIO_read(p_bio_b64, buf.data(), buf.size());
            if (nread  < 0) { throw std::runtime_error("BIO_read failed"); }
            if (nread == 0) { break; } // eof

            result.append(buf.data(), nread);
        }

        // clean
        BIO_free_all(p_bio_b64);

        return result;
    }
    catch (...)
    {
        if (p_bio_b64) { BIO_free_all(p_bio_b64); }
        throw;
    }
}

নোট করুন যে বেস 64৪_ডেকোড খালি স্ট্রিংটি ফিরিয়ে দেয়, যদি ইনপুটটি ভুল বেস 64 সিকোয়েন্স হয় (ওপেনসেল এইভাবে কাজ করে)।

— anton_rh
সূত্র
এইচএম ... ডিকোডিং / এনকোডিং বেস 64 এর জন্য ওপেনএসএল লাইব্রেরি ব্যবহার করে সরাসরি প্রয়োগের চেয়ে কোডের আরও বেশি লাইন লাগে (এই প্রশ্নের সেরা উত্তর) ...
— অ্যান্টন_আরহ
-2

এখানে গৃহীত উত্তরের জন্য এনকোডারটির একটি অনুকূলিত সংস্করণ রয়েছে, এটি এমআইএমআই এবং অন্যান্য প্রোটোকলের জন্য লাইন-ব্রেকিংও সমর্থন করে (সিমলার অপ্টিমাইজেশন ডিকোডারটিতে প্রয়োগ করা যেতে পারে):

 char *base64_encode(const unsigned char *data,
                    size_t input_length,
                    size_t *output_length,
                    bool addLineBreaks)

    *output_length = 4 * ((input_length + 2) / 3);
    if (addLineBreaks) *output_length += *output_length / 38; //  CRLF after each 76 chars

    char *encoded_data = malloc(*output_length);
    if (encoded_data == NULL) return NULL;

    UInt32 octet_a;
    UInt32 octet_b;
    UInt32 octet_c;
    UInt32 triple;
    int lineCount = 0;
    int sizeMod = size - (size % 3); // check if there is a partial triplet
    // adding all octet triplets, before partial last triplet
    for (; offset < sizeMod; ) 
    {
        octet_a = data[offset++];
        octet_b = data[offset++];
        octet_c = data[offset++];

        triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;

        encoded_data[mBufferPos++] = encoding_table[(triple >> 3 * 6) & 0x3F];
        encoded_data[mBufferPos++] = encoding_table[(triple >> 2 * 6) & 0x3F];
        encoded_data[mBufferPos++] = encoding_table[(triple >> 1 * 6) & 0x3F];
        encoded_data[mBufferPos++] = encoding_table[(triple >> 0 * 6) & 0x3F];
        if (addLineBreaks)
        {
            if (++lineCount == 19)
            {
                encoded_data[mBufferPos++] = 13;
                encoded_data[mBufferPos++] = 10;
                lineCount = 0;
            }
        }
    }

    // last bytes
    if (sizeMod < size)
    {
        octet_a = data[offset++]; // first octect always added
        octet_b = offset < size ? data[offset++] : (UInt32)0; // conditional 2nd octet
        octet_c = (UInt32)0; // last character is definitely padded

        triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;

        encoded_data[mBufferPos++] = encoding_table[(triple >> 3 * 6) & 0x3F];
        encoded_data[mBufferPos++] = encoding_table[(triple >> 2 * 6) & 0x3F];
        encoded_data[mBufferPos++] = encoding_table[(triple >> 1 * 6) & 0x3F];
        encoded_data[mBufferPos++] = encoding_table[(triple >> 0 * 6) & 0x3F];

        // add padding '='
        sizeMod = size % 3; 
        // last character is definitely padded
        encoded_data[mBufferPos - 1] = (byte)'=';
        if (sizeMod == 1) encoded_data[mBufferPos - 2] = (byte)'=';
    }
 }
— অমিত বেনস
সূত্র
আপনার স্নিপড এমনকি সংকলন করতে পারে না: আকারের কোনও ভেরিয়েবল নয় এবং আমি আশা করি যে এটি আপনার কোডে কোনও বৈশ্বিক পরিবর্তনশীল নয়।
— ম্যাক্স ল্যাপশিন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.