Visa källa för Base64

{{ofärdig}}
== Bakgrund ==

Tidigare system använde Unix-to-Unix Encoding (UUE) för att koda information på ett sätt att det gick att skicka genom en 7 bitars överföringskanal. Detta system är sedan länge övergivet i moderna datorsystem och i stället använder man Base64 som är en mer effektiv metod.

I korthet går det ut på att man tar in den data som skall kodas, delar upp det i symboler om 6 bitar och därefter kodar dem enligt ''Standardtabellen'' eller någon annan variant. Standardtabellen skall användas för all extern kommunikation eftersom det annars blir inkompatibelt mellan sändare och mottagare.

Se även [[Base32]].

== Procedur ==

Indatat ses som en ström oktetter. Dessa grupperas om 3, dvs i 24 bitar och delas sedan i 6-bitarstal så att det blir 4 stycken 6-bitarsgrupper. Varje sexbitarsgrupp har då ett värde som svarar mot en kod i tabellen och denna kod skickas i stället för 6-bitsgruppen. Om den sista gruppen inte är 3 bytes utan 2 eller 1 motsvarar det bara 2-3 siffror i Base64.

Base64 har fått sitt namn från att 2<sup>6</sup>=64, nämligen antalet symboler i listan som kan skickas.

Kodningen är baserad på följande:
* A-Z motsvarar 0-25
* a-z motsvarar 26-51
* 0-9 motsvarar 52-61
* '+' eller '-' motsvarar 62
* '/' eller '_' motsvarar 63

Anledningen till de två sista är ekvivalenta är för att det ibland kan vara så att vissa system använder endera som signaleringstecken eller liknande och då är det bättre att koda med det andra tecknet i stället. Man måste dock acceptera alla varianter som mottagare men kan välja hur man kodar som sändare. Observera att man EJ bör byta tecken inom samma block.

== Effektiviteten ==
Effektiviteten av kodningen är 3/4. Det betyder att för 24 bitar in produceras 32 bitar ut och det innebär att man därmed får en effektivitetssiffra på 0,75 vilket är ganska bra. Det är precis samma som för UUENCODE.

== Standardtabellen ==
{| border="1" cellpadding="2" cellspacing="0"
|-
! Värde
! Siffra
|rowspan=17|&nbsp;
! Värde
! Siffra
|rowspan=17|&nbsp;
! Värde
! Siffra
|rowspan=17|&nbsp;
! Värde
! Siffra
|-
| 0 || A || 16 || Q || 32 || g || 48 || w
|-
| 1 || B || 17 || R || 33 || h || 49 || x
|-
| 2 || C || 18 || S || 34 || i || 50 || y
|-
| 3 || D || 19 || T || 35 || j || 51 || z
|-
| 4 || E || 20 || U || 36 || k || 52 || 0
|-
| 5 || F || 21 || V || 37 || l || 53 || 1
|-
| 6 || G || 22 || W || 38 || m || 54 || 2
|-
| 7 || H || 23 || X || 39 || n || 55 || 3
|-
| 8 || I || 24 || Y || 40 || o || 56 || 4
|-
| 9 || J || 25 || Z || 41 || p || 57 || 5
|-
|10 || K || 26 || a || 42 || q || 58 || 6
|-
|11 || L || 27 || b || 43 || r || 59 || 7
|-
|12 || M || 28 || c || 44 || s || 60 || 8
|-
|13 || N || 29 || d || 45 || t || 61 || 9
|-
|14 || O || 30 || e || 46 || u || 62 || + -
|-
|15 || P || 31 || f || 47 || v || 63 || / _
|}

Exempel:
{|class="wikitable"
|-
!scope="row"| Text
|colspan="8" align="center"| '''M'''
|colspan="8" align="center"| '''a'''
|colspan="8" align="center"| '''n'''
|-
!scope="row"| ASCII-värden
|colspan="8" align="center"| 77
|colspan="8" align="center"| 97
|colspan="8" align="center"| 110
|-
!scope="row"| Bitmönster
|0||1||0||0||1||1||0||1||0||1||1||0||0||0||0||1||0||1||1||0||1||1||1||0
|-
!scope="row"| Värde per 6 bitar
|colspan="6" align="center"| 19
|colspan="6" align="center"| 22
|colspan="6" align="center"| 5
|colspan="6" align="center"| 46
|-
!scope="row"| Base64-kodat
|colspan="6" align="center"| '''T'''
|colspan="6" align="center"| '''W'''
|colspan="6" align="center"| '''F'''
|colspan="6" align="center"| '''u'''
|}


= Implementationsexempel = 

== C ==

<pre>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// BASE64 kodningstabell
static const char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// Funktion för BASE64 kodning (från tidigare)
char* base64_encode(const unsigned char* input, size_t length) {
    size_t output_length = 4 * ((length + 2) / 3);
    char* encoded = malloc(output_length + 1);
    
    if (encoded == NULL) return NULL;
    
    size_t i, j;
    for (i = 0, j = 0; i < length;) {
        unsigned int octet_a = i < length ? input[i++] : 0;
        unsigned int octet_b = i < length ? input[i++] : 0;
        unsigned int octet_c = i < length ? input[i++] : 0;
        
        unsigned int triple = (octet_a << 16) + (octet_b << 8) + octet_c;
        
        encoded[j++] = base64_table[(triple >> 18) & 0x3F];
        encoded[j++] = base64_table[(triple >> 12) & 0x3F];
        encoded[j++] = base64_table[(triple >> 6) & 0x3F];
        encoded[j++] = base64_table[triple & 0x3F];
    }
    
    switch (length % 3) {
        case 1:
            encoded[j - 2] = '=';
            encoded[j - 1] = '=';
            break;
        case 2:
            encoded[j - 1] = '=';
            break;
    }
    
    encoded[output_length] = '\0';
    return encoded;
}

// Funktion för BASE64 avkodning
unsigned char* base64_decode(const char* input, size_t* output_length) {
    size_t input_length = strlen(input);
    if (input_length % 4 != 0) return NULL; // Ogiltig BASE64-längd
    
    // Beräkna utdatalängd
    *output_length = input_length / 4 * 3;
    if (input[input_length - 1] == '=') (*output_length)--;
    if (input[input_length - 2] == '=') (*output_length)--;
    
    unsigned char* decoded = malloc(*output_length);
    if (decoded == NULL) return NULL;
    
    // Skapa lookup-tabell för snabbare avkodning
    unsigned char decode_table[256] = {0};
    for (int i = 0; i < 64; i++) {
        decode_table[(unsigned char)base64_table[i]] = i;
    }
    
    // Avkoda 4 tecken åt gången till 3 bytes
    for (size_t i = 0, j = 0; i < input_length;) {
        unsigned int sextet_a = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
        i++;
        unsigned int sextet_b = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
        i++;
        unsigned int sextet_c = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
        i++;
        unsigned int sextet_d = input[i] == '=' ? 0 : decode_table[(unsigned char)input[i]];
        i++;
        
        unsigned int triple = (sextet_a << 18) + (sextet_b << 12) + 
                            (sextet_c << 6) + sextet_d;
        
        if (j < *output_length) decoded[j++] = (triple >> 16) & 0xFF;
        if (j < *output_length) decoded[j++] = (triple >> 8) & 0xFF;
        if (j < *output_length) decoded[j++] = triple & 0xFF;
    }
    
    return decoded;
}

// Testprogram
int main() {
    const char* original = "Hello World!";
    size_t input_length = strlen(original);
    
    // Kodning
    char* encoded = base64_encode((const unsigned char*)original, input_length);
    if (!encoded) {
        printf("Kodningsfel\n");
        return 1;
    }
    
    // Avkodning
    size_t decoded_length;
    unsigned char* decoded = base64_decode(encoded, &decoded_length);
    if (!decoded) {
        printf("Avkodningsfel\n");
        free(encoded);
        return 1;
    }
    
    // Skriv ut resultat
    printf("Original: %s\n", original);
    printf("Encoded: %s\n", encoded);
    printf("Decoded: %.*s\n", (int)decoded_length, decoded);
    
    // Frigör minne
    free(encoded);
    free(decoded);
    
    return 0;
}
</pre>


[[category:Formatspecifikation]]
[[category:Telekommunikation]]
[[category:Data]]