Cryptopals - 1/1 - Convert hex to base64

W tym poście chciałbym opisać sposób konwersji wartości hex na base64.

Do zadania przygotuje dwa kody jeden w Go Lang, drugi w C. 

Dołączono tekst który ma zostać zapisany jako base64. 

1. 49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d

Podany ciąg po przekonwertowaniu na ASCII da następujące zdanie:

1. I'm killing your brain like a poisonous mushroom

Nie jest to konieczne do rozwiązania zadania. 

Po zakodowaniu ciągu bajtów jako ciąg znaków mam otrzymać:

1. SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t

Musimy wykonać następujące elementy w programie:

1 - zamiana HEX na bajty

2 - kodowanie base64

3 - wyświetlenie odpowiedzi.

Go:

Cały program wykonujące wspomniane wyżej zadania wygląda następująco:

1. package main
2. import (
3.  "encoding/hex"
4.  "encoding/base64"
5.  "fmt"
6. )
7. func main() {
8.     test := []byte("49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d")
9.    
10.     //Przygotowanie tablicy o długości
11.     decode := make([]byte, hex.DecodedLen(len(test)))
12.     //Przekowertowanie danych test na bajty do tablicy decode
13.     hex.Decode(decode, test)
14.    
15.     //Przygotowanie tablicy przechowującej zakodowane dane
16.     eb := make([]byte, base64.StdEncoding.EncodedLen(len(decode)))
17.     //Kodowanie base64
18.     base64.StdEncoding.Encode(eb, decode)
19.     //Wyświetlenie wyniku
20.     fmt.Printf("%s\r\n", eb)
21. }

Można go podzielić na podfunkcje, które będzie łatwiej wykorzystać w późniejszych zadaniach. 

1. package main
2. import (
3.  "encoding/hex"
4.  "encoding/base64"
5.  "fmt"
6. )
7.  
8. func decodeHex(array []byte) ([]byte, error) {
9.     db := make([]byte, hex.DecodedLen(len(array)))
10.     _, err := hex.Decode(db, array)
11.    
12.     if err != nil {
13.         return nil, err
14.     }
15.     return db, nil
16. }
17.  
18. func base64Encode(array []byte) ([]byte) {
19.     eb := make([]byte, base64.StdEncoding.EncodedLen(len(array)))
20.     base64.StdEncoding.Encode(eb, array)
21.  
22.     return eb
23. }
24.  
25. func main() {
26.     valueToBase := []byte("49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d")
27.     decodeHexArr, err := decodeHex(valueToBase)
28.    
29.     if err != nil {
30.         fmt.Printf("ERR to decode hex: %s", err)
31.         return
32.     }
33.  
34.     baseArr := base64Encode(decodeHexArr)
35.     fmt.Printf("%s", baseArr)
36. }

Program w C:

Wykorzystam tutaj gotową bibliotekę do base64 <link>. 

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
4.  
5. char base46_map[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
6.                      'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
7.                      'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
8.                      'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
9.  
10.  
11. char* base64_encode(char* plain) {
12.  
13.     char counts = 0;
14.     char buffer[3];
15.     char* cipher = malloc(strlen(plain) * 4 / 3 + 4);
16.     int i = 0, c = 0;
17.  
18.     for(i = 0; plain[i] != '\0'; i++) {
19.         buffer[counts++] = plain[i];
20.         if(counts == 3) {
21.             cipher[c++] = base46_map[buffer[0] >> 2];
22.             cipher[c++] = base46_map[((buffer[0] & 0x03) << 4) + (buffer[1] >> 4)];
23.             cipher[c++] = base46_map[((buffer[1] & 0x0f) << 2) + (buffer[2] >> 6)];
24.             cipher[c++] = base46_map[buffer[2] & 0x3f];
25.             counts = 0;
26.         }
27.     }
28.  
29.     if(counts > 0) {
30.         cipher[c++] = base46_map[buffer[0] >> 2];
31.         if(counts == 1) {
32.             cipher[c++] = base46_map[(buffer[0] & 0x03) << 4];
33.             cipher[c++] = '=';
34.         } else {                      // if counts == 2
35.             cipher[c++] = base46_map[((buffer[0] & 0x03) << 4) + (buffer[1] >> 4)];
36.             cipher[c++] = base46_map[(buffer[1] & 0x0f) << 2];
37.         }
38.         cipher[c++] = '=';
39.     }
40.  
41.     cipher[c] = '\0';   /* string padding character */
42.     return cipher;
43. }
44.  
45.  
46. char* base64_decode(char* cipher) {
47.  
48.     char counts = 0;
49.     char buffer[4];
50.     char* plain = malloc(strlen(cipher) * 3 / 4);
51.     int i = 0, p = 0;
52.  
53.     for(i = 0; cipher[i] != '\0'; i++) {
54.         char k;
55.         for(k = 0 ; k < 64 && base46_map[k] != cipher[i]; k++);
56.         buffer[counts++] = k;
57.         if(counts == 4) {
58.             plain[p++] = (buffer[0] << 2) + (buffer[1] >> 4);
59.             if(buffer[2] != 64)
60.                 plain[p++] = (buffer[1] << 4) + (buffer[2] >> 2);
61.             if(buffer[3] != 64)
62.                 plain[p++] = (buffer[2] << 6) + buffer[3];
63.             counts = 0;
64.         }
65.     }
66.  
67.     plain[p] = '\0';    /* string padding character */
68.     return plain;
69. }
70.  
71. void hexStringToByteArray(const char *hexString, unsigned char *byteArray, size_t byteArraySize) {
72.     for (size_t i = 0; i < byteArraySize; i++) {
73.         sscanf(hexString + 2 * i, "%2hhx", &byteArray[i]);
74.     }
75. }
76.  
77. int main()
78. {
79.     /* converted by hand
80.     char array[] = {0x49, 0x27, 0x6d, 0x20, 0x6b, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x79, 0x6f, 0x75, 0x72, 0x20, 0x62,
81.     0x72, 0x61, 0x69, 0x6e, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x61, 0x20, 0x70, 0x6f, 0x69, 0x73, 0x6f, 0x6e, 0x6f, 0x75, 0x73,
82.     0x20, 0x6d, 0x75, 0x73, 0x68, 0x72, 0x6f, 0x6f, 0x6d };
83.     */
84.    
85.     char string_array[] = "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d";
86.    
87.     size_t len = strlen(string_array) / 2;
88.     unsigned char array[len];
89.  
90.     hexStringToByteArray(string_array, array, len);
91.  
92.     char *code_array;
93.     code_array = base64_encode(&array[0]);
94.    
95.     printf("%s", code_array);
96.  
97.     return 0;
98. }

Program Python:

W Python wystarczą 4 linijki by całość działała poprawnie:

1. import base64
2.  
3. hex_string = "49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d"
4. bytes_data = bytes.fromhex(hex_string)
5. base64_encoded = base64.b64encode(bytes_data).decode("ascii")
6. print(f"Base64: {base64_encoded}")