Encryption/decryption by matrix multiplication in C
Welcome to Code Review, nice first question!

Perform Error Checking as Soon as Possible
The complexity of the code can be decreased by performing earlier error checking in the function decode_it. If the code was changed so that source_file was tested at the beginning there would be less indentation
and the code would be easier to follow:

void decode_it(char* source_decode ,int* matrice_identity){

    FILE* source_file = NULL;
    source_file = fopen(source_decode, "rb");
    if (source_file == NULL)
    {
        printf("read failed");
        return;
    }


Don't Assume the Buffer has the Necesary Capacity
There is a possible critical error in the following code:

    char* exetention = "d";
    strcat(source_decode, exetention);


The variable source_code may not have enough space allocated to append the extention. This can cause the program to crash, especially when the code is optimized. Allocate a new string with enough space to accept the file name and the extension.

    char* decoded_fname = malloc(strlen(source_decode) + strlen(exetention) + 1);  // leave room for NULL termination
    strcpy(decoded_fname, source_decode);
    strcat(source_decode, exetention);


Reduce Complexity, Follow SRP

The Single Responsibility Principle states that every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class. All its services should be narrowly aligned with that responsibility.

Robert C. Martin expresses the principle as follows:


  A class should have only one reason to change.


While this is primarily targeted at classes in object oriented languages it applies to functions and subroutines in procedural languages like C as well.

The decode_it() function can be broken up into smaller functions to make it more readable, and to allow you to profile the program
to see where you are spending the most time.

The following is a good candidate for a function:

            for (j = 0; j&lt;4; j++) {
                for (i = 0; i&lt;8; i++) {
                    if (i == matrice_identity[j]) {
                        result[j] = octet1[i];
                        result[j + 4] = octet2[i];
                    }
                }
            }


Another good candidate for a function is the code

            int k = 0;
            int printFile = 0;
            for (i = 7; i &gt;= 0; i--) {
                printFile += result[i] * (int)pow(2., (double)k);
                k++;
            }


Please note in the previous I cast the result of pow function to int, my compiler gave me a warning message on that line.

Possible Optimizations
Rather than reading the input file character by character input large chunks of data (file block size perferably) into a large
buffer internal to the program and process the buffer instead. Each time fgetc is called it is making a system call which is
expensive(time consuming). Having an input buffer and processing it may help reduce the complexity of the code as well.

For the same reason, create a string output buffer and write it to the file all at once rather than repeatedly calling fprintf().

Using pointers rather than array indexes may also improve performance.