les lycéens aussi veulent faire mardi gras

En tant que lycéens, j'ai décidé de partir sur la chose qui me paraissait la plus opti, rapide et simple. Soit calculer le temps de réalisation d'un proof of work, de répéter l'opération plusieurs fois et de faire un petit calcul avec les résultats pour finir par un %12 histoire d'avoir un truc bien pseudo aléatoire. Pour ce qui est de l'optimisation, j'ai codé moi-même toutes les fonctions, même celle du sha256, une merveille d'ingéniosité.
Si tu veux me contacter pour mes talents de développeur, c'est mon discord edit : j'ai oublier de dire que le code marche sous linux mais probablement pas win10 vue qu'il y a un peu d'ansi escape code
/*
   Ce code est la preuve que les lycéens aussi code mal

   la fonction intérresante (celle qui choisi le string) se situe l : 229 

   ps : sympa pour le vote ;-) et avant que tu m'insulte n'oublie pas que 
        le but c'était de pas faire du bon code
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <time.h>

//elle sont pas super intérresante donc tout en bas
char* stringToBinary(char* s);
long int puissance(long int a,long int b);
char *intToBin64(int64_t n);
char *intToBin32(int32_t n);
long int binToDec(char *arr);
char *rotateByOne(char *arr); //celle ci elle sert à r......
char *rightRotate(char *arr,int n);
void binaryToHex(const char *inStr, char *outStr);
char valueOf(char *demi);
char *binToHex(char *binary);

//  je te laisse aprécié cette approche du sha 256 ^^
//  Quoi de mieux que d'utiliser des string afin de mieux visualiser les
//  nombre en binaire ^^

char *sha256(char *ahasher){
    long int hl[8] = {
        0x6a09e667,
        0xbb67ae85,
        0x3c6ef372,
        0xa54ff53a,
        0x510e527f,
        0x9b05688c,
        0x1f83d9ab,
        0x5be0cd19
    };

    long int k[64] = {
        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
    };

    char binary[512];
    binary[0] = '\0';
    strcat(binary,stringToBinary(ahasher));

    //printf("entrée : %s\n",ahasher);
    //printf("to bin : %s\n",binary);

    int64_t len = strlen(binary) - 1;

    strcat(binary,"1");

    for(int i = strlen(binary); i < 512-64; i++ ){
        strcat(binary,"0");
    }

    strcat(binary,intToBin64(len+1));

    /*for(int i=0; i < strlen(binary); i++){ //les com ça sert à ça....
        if (i % 8 == 0)
        {
            printf(" ");
        }
        if (i % 64 == 0)
        {
            printf("\n");
        }
        printf("%c",binary[i]);
    }
    */
    //printf("\n\n");

    char w[64][33];

    //refaire le ptn de tableau enfaite c'est bon
    for(int i = 0,j = 0, l = 0; i<strlen(binary); i++){
        if (j == 32)
        {
            l++;
            j = 0;
        }
        if (j == 0)
        {
            w[l][32] = '\0';
        }
        w[l][j] = binary[i];
        j++;
    }

    for(int i = 16; i < 64; i++ ){
        for(int j = 0;j < 32;j++){
            w[i][j] = '0';
        }
        w[i][32] = '\0';
    }
    for (int i = 16; i < 64; ++i)
    {
        char tempo32[3][33];
        for (int j = 0; j < 3; ++j)
        {
            tempo32[j][0] = '\0';
            strcat(tempo32[j],w[i-15]);
        }

        long int s0 = binToDec((rightRotate(tempo32[0],7))) ^ binToDec(rightRotate(tempo32[1],18)) ^ (binToDec(tempo32[2]) >> 3); 

        char tempo232[3][33];
        for (int j = 0; j < 3; ++j)
        {
            tempo232[j][0] = '\0';
            strcat(tempo232[j],w[i-2]);
        }
        long int s1 = binToDec((rightRotate(tempo232[0],17))) ^ binToDec(rightRotate(tempo232[1],19)) ^ (binToDec(tempo232[2]) >> 10);

        long int wi = (binToDec(w[i-16]) + s0 + binToDec(w[i-7]) + s1) % puissance(2,32);

        strcpy(w[i], intToBin32(wi));
        w[i][32] = '\0';
    }
    /*for (int i = 0; i < 64; ++i)
    {
        printf("  %s",w[i]);
        if (i%2 != 0)
        {
            printf("\n");
        }
    }*/

    /*!!!!!!!!!!!!!!!!!!!!! à refaire !!!!!!!!!!!!!!!!!!!!! (marche moyen)*/

    char a[33],b[33],c[33],d[33],e[33],f[33],g[33],h[33];

    strcpy(a,intToBin32(hl[0]));
    strcpy(b,intToBin32(hl[1]));
    strcpy(c,intToBin32(hl[2]));
    strcpy(d,intToBin32(hl[3]));
    strcpy(e,intToBin32(hl[4]));
    strcpy(f,intToBin32(hl[5]));
    strcpy(g,intToBin32(hl[6]));
    strcpy(h,intToBin32(hl[7]));

    for (int i = 0; i < 64; ++i)
    {
        char previous[33];
        char previous2[33];

        for(int j = 0;j<33;j++){
            previous[j] = '\0';
        }
        for(int j = 0;j<33;j++){
            previous2[j] = '\0';
        }

        strcpy(previous,e);

        long int S1 = binToDec(rightRotate(e,6));
        strcpy(e,previous);
        S1 ^= binToDec(rightRotate(e,11));
        strcpy(e,previous);
        S1 ^= binToDec(rightRotate(e,25));
        strcpy(e,previous);

        long int ch = (binToDec(e)&binToDec(f)) ^ ((~binToDec(e))& binToDec(g));

        long int temp1 = (binToDec(h) + S1 + ch +  k[i] + binToDec(w[i]))%puissance(2,32);

        strcpy(previous2,a);
        long int S0 = binToDec(rightRotate(a,2));
        strcpy(a,previous2); 
        S0 ^= binToDec(rightRotate(a,13));
        strcpy(a,previous2);
        S0 ^= binToDec(rightRotate(a,22));
        strcpy(a,previous2);

        long int maj = (binToDec(a)&binToDec(b)) ^ (binToDec(a)&binToDec(c)) ^ (binToDec(b)&binToDec(c));

        long int temp2 = (S0 + maj)%puissance(2,32);

        strcpy(e,previous);
        strcpy(a,previous2);

        strcpy(h,g);
        strcpy(g,f);
        strcpy(f,e);
        strcpy(e,intToBin32((binToDec(d) + temp1)%puissance(2,32)));
        strcpy(d,c);
        strcpy(c,b);
        strcpy(b,a);
        strcpy(a,intToBin32((temp1 + temp2)%puissance(2,32)));         
    }

    hl[0] = (hl[0] + binToDec(a))%puissance(2,32);
    hl[1] = (hl[1] + binToDec(b))%puissance(2,32);
    hl[2] = (hl[2] + binToDec(c))%puissance(2,32);
    hl[3] = (hl[3] + binToDec(d))%puissance(2,32);
    hl[4] = (hl[4] + binToDec(e))%puissance(2,32);
    hl[5] = (hl[5] + binToDec(f))%puissance(2,32);
    hl[6] = (hl[6] + binToDec(g))%puissance(2,32);
    hl[7] = (hl[7] + binToDec(h))%puissance(2,32);

    char *final = malloc(8*32 + 1);final[0] = '\0';

    for(int i = 0;i < 8;i++){
        strcat(final,intToBin32(hl[i]));
    }

    char *hexfinal = malloc(256);
    strcpy(hexfinal, binToHex(final));

    free(final);

    return hexfinal;
}

//!!!!!!!!!!!!!!!!!!!!!!!!la fameuse!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

char *element_aleatoire(char **array){
    char *word = malloc(64);
    char diff;
    char *tempo = malloc(3);

    printf("\ntu veux que ce soit rapide ? [N/y] ");
    fgets(tempo,3,stdin);

    diff = tempo[0];

    if (diff != 'y')
    {
        diff = 'N';
    }

    printf("un mot gentil pour l'entropie : ");
    fgets(word,64,stdin);

    printf("hash : %s\n\n",sha256(word));
    fflush(stdout);
    clock_t begin = clock();
    clock_t prev = begin;

    int result [6];
    int tot = 1;
    for (int j = 0; j < 5; ++j)
    {
        long int nbr = 0;

        while(nbr <= 2000000){

            char snbr[11];
            sprintf(snbr,"%ld",nbr);
            char *reponse = malloc(strlen(word) + strlen(snbr) + 1);

            reponse[0] = '\0';

            strcat(reponse,word);strcat(reponse,snbr);

            //printf("%s:",reponse);
            char *hashrep = sha256(reponse);
            //printf("%s\n",hashrep);
            char test[4];
            if (diff == 'N')
            {
                test[4] = 0;
                for (int i = 0; i < 4; ++i)
                {
                    test[i] = hashrep[i];
                }
            }
            else{
               test[3] = 0;
                for (int i = 0; i < 3; ++i)
                {
                    test[i] = hashrep[i];
                } 
            }

            //printf("d : %s\n",test);
           if ( nbr == 1000 && j == 0)
            {
                clock_t esti = clock();
                unsigned long millis = (esti -  begin) * 1000 / CLOCKS_PER_SEC;
                printf("\n!!! tkt je mine pas du bitcoin sur ton pc juste je choisi un plat !!!\n\n");

                fflush(stdout);
                long int tmax;

                if (diff == 'N')
                {
                    tmax = 200 * 4 * millis / 1000;
                }
                else{
                    tmax = 6 * 4 * millis / 1000;
                }
                printf("temps max estimé : %ldmin %lds\r", tmax / 60,tmax%60);

                printf("\n\netat : \033[38;2;12;173;14m[                         ]  0%%");
                fflush(stdout);
            }

            if(diff == 'N'){
                if (strcmp(test,"0000") == 0)
                {
                    clock_t end = clock();
                    unsigned long millis = (end -  begin) * 1000 / CLOCKS_PER_SEC;
                    //unsigned long secondes = (unsigned long) difftime( fin, debut );
                    //printf("\nfini en %ld ms !!!\nchoix n°%ld\n",millis,millis%12);
                    result[j] = millis%12;
                    nbr = 0;

                    printf("\033[30D");
                    //fflush(stdout);

                    /*if (j+1 < 5)//au début je voulait une meilleur gestion
                                  // de la couleur mais flemme
                    {
                        printf("\033[38;2;234;4;4m");
                    }
                    else{
                        printf("\033[38;2;12;173;14m");
                    }
                    */
                    //fflush(stdout);
                    for(int k = 0; k < (j+1)*5;k++){
                        printf("#");
                    }
                    for(int k = 25 - 5 * (j+1);k > 0;k--){
                        printf(" ");
                    }
                    printf("] %d%%",(j+1)*20);
                    fflush(stdout);

                    break;
                }
            }
            else{
                if (strcmp(test,"000") == 0)
                {
                    clock_t end = clock();
                    unsigned long millis = (end -  begin) * 1000 / CLOCKS_PER_SEC;
                    //unsigned long secondes = (unsigned long) difftime( fin, debut );
                    //printf("\nfini en %ld ms !!!\nchoix n°%ld\n",millis,millis%12);
                    result[j] = millis%12;
                    nbr = 0;

                    printf("\033[30D");
                    for(int k = 0; k < (j+1)*5;k++){
                        printf("#");
                    }
                    for(int k = 25 - 5 * (j+1);k > 0;k--){
                        printf(" ");
                    }
                    printf("] %d%%",(j+1)*20);
                    fflush(stdout);

                    break;
                }
            }

            nbr++;
        }

    }
    int vrairesult = 1;

    for(int i = 0; i<5;i++){
        vrairesult += result[i];
    }
    printf("\033[0m");
    return array[vrairesult%12];
}

//le main pour tester

int main(void)
{
    char *les_specialites_regionales_de_mardi_gras[] = {"gaufres", "croustillons du ch'nord", "bugnes", "ganses", "pets de nonne", "roussettes", "merveilles", "crouchepettes", "bougnettes", "beugnot", "bottereaux", "oreillettes"};

    printf("\n\nspécialité choisie : %s\n\n",element_aleatoire(les_specialites_regionales_de_mardi_gras));

    printf("\033[4m\033[1m\033[38;2;242;80;0m\t\tby robinson !!!\033[0m\n\n");
    return 0;
}

//les qlqs fonctions codé pour l'occasion mais pas intérrésante

char* stringToBinary(char* s) {
    if(s == NULL) return 0;
    size_t len = strlen(s);
    char *binary = malloc(len*8 + 1);
    binary[0] = '\0';
    for(size_t i = 0; i < len; ++i) {
        char ch = s[i];
        for(int j = 7; j >= 0; --j){
            if(ch & (1 << j)) {
                strcat(binary,"1");
            } else {
                strcat(binary,"0");
            }
        }
    }
    return binary;
}

long int puissance(long int a,long int b){
    long int debut = a;
    for (int i = 0; i <= b-2; ++i)
    {
        a = a * debut;
    }
    return a;   
}

char *intToBin64(int64_t n)
{
    unsigned long i;
    char *binary = malloc(65);

    i = 1UL<<(sizeof(n)*CHAR_BIT-1);
    while(i>0){
         if(n&i)
              strcat(binary,"1"); 
         else 
              strcat(binary,"0"); 
         i >>= 1;
    }
    return binary;
}
char *intToBin32(int32_t n)
{
    long int i;
    char *binary = malloc(33);

    i = 1L<<(sizeof(n)*CHAR_BIT-1);
    while(i>0){
         if(n&i)
              strcat(binary,"1"); 
         else 
              strcat(binary,"0"); 
         i >>= 1;
    }
    return binary;
}
long int binToDec(char *arr){
    long int result = 0;
    long int j = 31;
    for (long int i = 0; i <= 31; ++i)
    {
        if (arr[i] == '1')
        {
            result += puissance(2,j);
            if (i == 31)
            {
                result--;
            }
        }   
        j--;
    }
    return result;
}

char *rotateByOne(char *arr)
{
    int i, last;
    int len = strlen(arr);
    last = arr[len - 1];

    for(i=len-1; i>0; i--)
    {
        arr[i] = arr[i - 1];
    }

    arr[0] = last;
    return arr;
}

char *rightRotate(char *arr,int n){

    int length = strlen(arr);

    for(int i = 0; i < n; i++){    
        int j, last;        
        last = arr[length-1];    

        for(j = length-1; j > 0; j--){       
            arr[j] = arr[j-1];    
        }    

        arr[0] = last;    
    } 
    return arr;
}

void binaryToHex(const char *inStr, char *outStr) {

    static char hex[] = "0123456789ABCDEF";
    int len = strlen(inStr) / 4;
    int i = strlen(inStr) % 4;
    char current = 0;
    if(i) { 
        while(i--) {
            current = (current << 1) + (*inStr - '0');
            inStr++;
        }
        *outStr = hex[current];
        ++outStr;
    }
    while(len--) {
        current = 0;
        for(i = 0; i < 4; ++i) {
            current = (current << 1) + (*inStr - '0');
            inStr++;
        }
        *outStr = hex[current];
        ++outStr;
    }
    *outStr = 0;
}

char valueOf(char *demi)
{
    if(strcmp(demi, "0000") == 0)
        return '0';
    if(strcmp(demi, "0001") == 0)
        return '1';
    if(strcmp(demi, "0010") == 0)
        return '2';
    if(strcmp(demi, "0011") == 0)
        return '3';
    if(strcmp(demi, "0100") == 0)
        return '4';
    if(strcmp(demi, "0101") == 0)
        return '5';
    if(strcmp(demi, "0110") == 0)
        return '6';
    if(strcmp(demi, "0111") == 0)
        return '7';
    if(strcmp(demi, "1000") == 0)
        return '8';
    if(strcmp(demi, "1001") == 0)
        return '9';
    if(strcmp(demi, "1010") == 0)
        return 'A';
    if(strcmp(demi, "1011") == 0)
        return 'B';
    if(strcmp(demi, "1100") == 0)
        return 'C';
    if(strcmp(demi, "1101") == 0)
        return 'D';
    if(strcmp(demi, "1110") == 0)
        return 'E';
    if(strcmp(demi, "1111") == 0)
        return 'F';
    return 0;
}

char *binToHex(char *binary)
{
    char *hex = malloc(strlen(binary)/4+1);
    for (int i = 0,j =0; i < strlen(binary); i+=4)
    {
        char demi[4];

        for(int k = 0; k < 4; k++){
            demi[k] = binary[i+k];
        }
        demi[4]=0;

        char hexU = valueOf(demi);

        hex[j] = hexU;
        j++;
        hex[j] = '\0';
    }

    return hex;
}

//alors pas mal non ^^
j'en suis plutôt fier donc si ça me permet de gagner je serai encor plus content ^^
CoddityTeam / movaicode

les lycéens aussi veulent faire mardi gras #202
