Wie kodiere (dekodiere) ich base64 in C?

Lesezeit: 15 Minuten

Ich habe binäre Daten in einer unsigned char-Variablen. Ich muss sie in c in PEM base64 konvertieren. Ich habe in der Openssl-Bibliothek nachgesehen, aber ich konnte keine Funktion finden. Hat jemand eine Idee?

  • Ich habe ein Github-Repository mit getesteten base64- und unbase64-Funktionen. Der einzige Header, den Sie benötigen, ist base64.h

    – bobobobo

    17. April 2013 um 22:17 Uhr

  • Leider sind die meisten Antworten hier völlig off-topic. C++ ist nicht C.

    – Joe Coder

    24. April 2020 um 7:44 Uhr

  • @JoeCoder Siehe Kommentar zu libb64 unten.

    – Jonathan Ben-Avraham

    6. September um 11:20 Uhr

Benutzeravatar von ryyst
ryyst

Hier ist die, die ich verwende:

#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', '+', "https://stackoverflow.com/"};
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);
}

Denken Sie daran, dass dies keine Fehlerprüfung während der Dekodierung durchführt – nicht mit Base 64 kodierte Daten werden verarbeitet.

  • Es macht keinen Sinn, dies zu verwenden, wenn es eine Bibliothek gibt.

    – Diego Woitasen

    18. Juli 2012 um 15:35 Uhr

  • Sie können die “Abhängigkeit” von libm und math.h sowie die Notwendigkeit von Gleitkommaoperationen (die auf mancher Hardware langsam sind) überspringen, indem Sie verwenden *output_length = ((input_length - 1) / 3) * 4 + 4; am Anfang von base64_encode.

    – Fabian Henze

    8. September 2012 um 15:54 Uhr

  • Mir ist klar, dass es sich um “keine Fehlerprüfung” handelt, aber beachten Sie insbesondere, dass, obwohl die Decodiertabelle im Decoder ein Array von 256 ist, Sie wirklich von -128 bis 127 indizieren, da char auf den meisten Architekturen signiert ist. Jedes Zeichen mit dem High Bit gesetzt bewirkt, dass Sie außerhalb des zugewiesenen Speichers lesen. Das Erzwingen der Datensuche als unsigned char klärt das auf. Sie erhalten immer noch Müll für Müll, aber Sie werden keinen Segfault haben.

    – Bitmusher

    12. Februar 2013 um 14:54 Uhr

  • Sie haben ein Array-Out-of-Bounds-Problem in build_decoding_table. encoding_table[64] zu encoding_table[255] existiert nicht.

    – bobobobo

    17. April 2013 um 19:12 Uhr


  • Die Dekodierung behandelt auch nicht die Situation, in der die Auffüllung “=” fehlt. Zusammen mit allen anderen Fehlern eine ziemlich schlechte Umsetzung.

    – Lothar

    10. März 2015 um 11:45 Uhr

Benutzeravatar von GaspardP
GaspardP

Ich weiß, dass diese Frage ziemlich alt ist, aber ich war verwirrt von der Menge der bereitgestellten Lösungen – jede von ihnen behauptete, schneller und besser zu sein. Ich habe ein Projekt auf github zusammengestellt, um die base64-Encoder und -Decoder zu vergleichen: https://github.com/gaspardpetit/base64/

An dieser Stelle habe ich mich nicht auf C-Algorithmen beschränkt – wenn eine Implementierung in C++ gut funktioniert, kann sie leicht nach C zurückportiert werden. Es wurden auch Tests mit Visual Studio 2015 durchgeführt. Wenn jemand diese Antwort mit Ergebnissen von clang/ aktualisieren möchte gcc, sei mein Gast.

SCHNELLSTE ENCODER:
Die beiden schnellsten Encoder-Implementierungen, die ich gefunden habe, stammen von Jouni Malinen http://web.mit.edu/freebsd/head/contrib/wpa/src/utils/base64.c und der Apache bei https://opensource.apple.com/source/QuickTimeStreamingServer/QuickTimeStreamingServer-452/CommonUtilitiesLib/base64.c.

Hier ist die Zeit (in Mikrosekunden), um 32 KB Daten mit den verschiedenen Algorithmen zu codieren, die ich bisher getestet habe:

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

(Die Lösung von René Nyffenegger, die in einer anderen Antwort auf diese Frage gutgeschrieben wird, ist hier als adp_gmbh aufgeführt).

Hier ist die von Jouni Malinen, die ich leicht modifiziert habe, um einen std::string zurückzugeben:

/*
* Base64 encoding/decoding (RFC1341)
* Copyright (c) 2005-2011, Jouni Malinen <[email protected]>
*
* 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;
}

SCHNELLSTE DECODER: Hier sind die Dekodierungsergebnisse und ich muss zugeben, dass ich etwas überrascht bin:

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

Das Snippet von Polfosol aus dem base64-Decodierungs-Snippet in C++ ist mit einem Faktor von fast 2x am schnellsten.

Hier der Vollständigkeit halber der Code:

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;
}

  • Ich glaube wirklich nicht, dass std::string und die restlichen Funktionen, die Sie verwendet haben, Teile von ANSI C sind.

    – SF.

    23. August 2017 um 10:24 Uhr

  • Wenn man eine Lösung sucht, die sowohl zum Dekodieren als auch zum Kodieren gut funktioniert, ohne Code von zwei Stellen nehmen zu müssen, würde ich die Apache-Version für C und die Lösung von Polfosol für C++ wählen

    – DaedalusAlpha

    7. Februar 2018 um 9:57 Uhr


  • @GaspardP Kann Polfosols Dekodierung für Jounis Kodierung verwendet werden?

    – Sam Thomas

    24. Mai 2018 um 1:13 Uhr

  • @SamThomas ja, alle getesteten Methoden liefern die gleiche Ausgabe und sind austauschbar.

    – GaspardP

    13. Dezember 2020 um 0:23 Uhr

  • @GaspardP Möchten Sie ein wenig von Ihrem Repository und Ihren Tests aktualisieren? 🙂 Hier ist die umgeschriebene Quelle mit Jounimalinen zum Codieren und Polfosol zum Decodieren. Es wurde gemäß MISRA C:2012-Codierungsrichtlinie so umgeschrieben, dass es Automotive/Avionik-konform ist. github.com/IMProject/IMUtility/blob/main/Src/base64.c übrigens. Wir erwarten nicht, die Schnellsten zu sein, aber die Schnellsten und Sichersten 🙂

    – Igor Mišić

    7. April um 14:27 Uhr


Aber Sie können es auch in openssl (openssl enc Befehl tut es ….), schau dir die an BIO_f_base64() Funktion

  • Es scheint, als würde das OP OpenSSL bereits aus einem anderen Grund verwenden, daher ist dies wahrscheinlich der beste Weg, dies zu tun.

    – joshk0

    30. April 2009 um 18:19 Uhr

libb64 hat sowohl C- als auch C++-APIs. Es ist leichtgewichtig und vielleicht die schnellste öffentlich verfügbare Implementierung. Es ist auch eine dedizierte, eigenständige base64-Codierungsbibliothek, was nett sein kann, wenn Sie nicht all die anderen Dinge benötigen, die durch die Verwendung einer größeren Bibliothek wie OpenSSL oder glib entstehen.

Benutzeravatar von schulwitz
Schulwitz

Hier ist meine Lösung mit OpenSSL.

/* 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.
}

  • In der Zeile “Adds a null-terminator” erhalte ich einen AddressSanitizer-Fehler, dass der Schreibvorgang den Heap um 1 Byte überläuft.

    – Parker

    18. Januar 2014 um 18:16 Uhr

  • Danke, ich habe den Fehler korrigiert und zusätzlich umfangreiche Tests mit zufällig großen Zeichenfolgen aus zufälligen Bytes durchgeführt, um sicherzustellen, dass der Code wie angekündigt funktioniert. 🙂

    – Schulwitz

    11. März 2015 um 3:33 Uhr


  • HÜBSCH! Ich habe es mit kompiliert cc -o base base.c -lssl -lcrypto. Keine Fehler. Es erzeugte diese Ausgabe: Original character string is: Base64 encode this string! Base-64 encoded string is: QmFzZTY0IGVuY29kZSB0aGlzIHN0cmluZyE= Base-64 decoded string is: Base64 encode this string!

    – klares Licht

    21. März 2017 um 16:34 Uhr


  • @SamThomas Die Verwendung von strlen funktioniert in meinem Beispiel, weil ich eine Zeichenfolge erstellt habe, in der nur ein Nullterminator vorhanden ist (und sich am Ende der Zeichenfolge befindet). Sehen: tutorialspoint.com/cprogramming/c_strings.htm Das Einlesen von jarFile mit strlen schlägt fehl, da wahrscheinlich ein Null-Terminator in der Mitte Ihrer Binärdatei vorhanden ist, der den bytes_to_decode-Wert durcheinander bringt. Siehe: stackoverflow.com/questions/24596189/… Finden Sie die Größe Ihrer Datei auf andere Weise: stackoverflow.com/questions/238603/…

    – Schulwitz

    7. Juni 2018 um 17:49 Uhr


  • Dies hat zumindest in der Version openssl1.1 auf Ubuntu 20.04 ein Speicherleck

    – Ericcurtin

    8. Juli 2020 um 15:25 Uhr

glib hat Funktionen für die base64-Kodierung: https://developer.gnome.org/glib/stable/glib-Base64-Encoding.html

  • In der Zeile “Adds a null-terminator” erhalte ich einen AddressSanitizer-Fehler, dass der Schreibvorgang den Heap um 1 Byte überläuft.

    – Parker

    18. Januar 2014 um 18:16 Uhr

  • Danke, ich habe den Fehler korrigiert und zusätzlich umfangreiche Tests mit zufällig großen Zeichenfolgen aus zufälligen Bytes durchgeführt, um sicherzustellen, dass der Code wie angekündigt funktioniert. 🙂

    – Schulwitz

    11. März 2015 um 3:33 Uhr


  • HÜBSCH! Ich habe es mit kompiliert cc -o base base.c -lssl -lcrypto. Keine Fehler. Es erzeugte diese Ausgabe: Original character string is: Base64 encode this string! Base-64 encoded string is: QmFzZTY0IGVuY29kZSB0aGlzIHN0cmluZyE= Base-64 decoded string is: Base64 encode this string!

    – klares Licht

    21. März 2017 um 16:34 Uhr


  • @SamThomas Die Verwendung von strlen funktioniert in meinem Beispiel, weil ich eine Zeichenfolge erstellt habe, in der nur ein Nullterminator vorhanden ist (und sich am Ende der Zeichenfolge befindet). Sehen: tutorialspoint.com/cprogramming/c_strings.htm Das Einlesen von jarFile mit strlen schlägt fehl, da wahrscheinlich ein Null-Terminator in der Mitte Ihrer Binärdatei vorhanden ist, der den bytes_to_decode-Wert durcheinander bringt. Siehe: stackoverflow.com/questions/24596189/… Finden Sie die Größe Ihrer Datei auf andere Weise: stackoverflow.com/questions/238603/…

    – Schulwitz

    7. Juni 2018 um 17:49 Uhr


  • Dies hat zumindest in der Version openssl1.1 auf Ubuntu 20.04 ein Speicherleck

    – Ericcurtin

    8. Juli 2020 um 15:25 Uhr

GNU Coreutils hat es in lib/base64. Es ist ein wenig aufgebläht, befasst sich aber mit Dingen wie EBCDIC. Sie können auch alleine herumspielen, z.

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;
}

Erkenne alle Personen an diesen Geschenken, dass du „selbst herumspielen“ nicht mit „einen Standard umsetzen“ verwechseln solltest. Ja.

  • Ebenfalls, '+' ist 62 und '/' ist 63 in PEM base64, wie von OP gefordert. Hier ist eine Liste von base64-Codierungsvarianten. Ich sehe keine Base64-Codierungsvariante mit der Reihenfolge der von Ihnen verwendeten Zeichen. Aber die Mathematik hinter dem Algorithmus ist korrekt.

    – Patrick

    28. Oktober 2012 um 3:53 Uhr

  • Wie schon gesagt: Seien Sie vorsichtig, dieser Algorithmus ist nicht kompatibel mit gemeinsames base64

    – Zerber

    15. November 2012 um 17:34 Uhr

  • Was ist mit Codierung?

    – Geremia

    30. Januar 2016 um 1:28 Uhr

1424480cookie-checkWie kodiere (dekodiere) ich base64 in C?

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy