/*************************************************************************************************************************************/
/* */
/* P E R M U T A T I O N " A L E A T O I R E " E T R E V E R S I B L E D ' O C T E T S : */
/* */
/* */
/* ATTENTION : */
/* */
/* Le 20041207150048, cette commande a ete */
/* deplacee de '$xcg' a '$xcS' pour des raisons */
/* de securite. Etant donc dans '$xcS', son source */
/* '$K' peut etre crypte (par exemple sur '$CMAP??'). */
/* Il convient alors de le decrypter dans '$DStemporaires' */
/* (afin de'eviter qu'ils puissent apparaitre dans les */
/* "snapshots"s) et de deplacer ensuite le '$X' dans '$xcS' */
/* "a la main" (cela explique les modifications 'v $xcc/cpp$Z 20050110150327' */
/* destinees a automatiser cela...). */
/* */
/* Le 20070309101750, cette commande a ete */
/* redeplacee de '$xcS' a '$xcg' pour eviter des */
/* problemes dans le cas ou pour une raison ou pour */
/* une autre il deviendrait impossible de la compiler */
/* parce que son '$X' ne fonctionnerait plus (problemes */
/* de librairies par exemple...). */
/* */
/* Le 20050915101021, je note qu'il y a une */
/* difficulte du type "l'oeuf et la poule" en ce */
/* qui concerne le demarrage a froid d'une nouvelle */
/* MACHINE sur laquelle un fichier tel '$xcg/ShufBytes.01$K' */
/* doit etre crypte. En effet comment le crypter et le */
/* compiler, tant qu'il n'est pas compile ? Le probleme */
/* est resolu grace a 'v $Falias_fcrypte 20050915102252' */
/* et grace a 'v $Falias_fdecrypte 20050915102516' */
/* ou l'on peut donner un nom vide en ce qui concerne */
/* l'outil Prive de Cryptage, ce qui signifie alors */
/* qu'il est absent. Alors seul sera utilise l'outil */
/* Systeme de Cryptage (pour crypter et decrypter...). */
/* */
/* */
/* Author of '$xcg/ShufBytes.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20041202091715). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
@define PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES
/* Introduit le 20061110085954 lors des "grandes manoeuvres" concernant le nom de nombreux */
/* symboles de type 'Common'. Sur '$CMAP28' la commande '$xcg/ShufBytes.01$X' ne pouvait */
/* plus s'executer car, en effet, elle reclamait dynamiquement des symboles qui n'existaient */
/* plus, or pour 'v $xcg/ShufBytes.01$K', il fallait '$xcg/ShufBytes.01$X' pour decrypter... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_MINI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define EDITER_LA_TABLE_DES_PERMUTATIONS \
FAUX \
/* Faut-il seulement editer la table des permutations ('VRAI') ou bien faire un */ \
/* cryptage/decryptage ('FAUX') ? */
#define C_EST_L_OPERATION_DIRECTE \
VRAI \
/* Est-ce l'operation directe dite "chiffrage" ('VRAI') ou l'operation inverse dite */ \
/* "dechiffrage" ('FAUX') ? */
#define GENERER_UNE_OPERATION_NEUTRE \
FAUX \
/* Doit-on faire du cryptage/decryptage ('FAUX') ou bien une operation neutre ('VRAI'), */ \
/* c'est-a-dire ne pas crypter/decrypter ? Ceci fut introduit le 20070306093201.... */
#define DIVISEUR_DE_CRYPTAGE \
UN
#define DIVISEUR_DE_DECRYPTAGE \
QUATRE
/* Diviseurs des clefs de cryptage/decryptage (introduit le 20041204115821) compatibles */
/* avec 'v $Falias_decrypte DiViSeUr'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define CLEF_DE_CRYPTAGE_DECRYPTAGE_NON_DEFINIE \
ZERO
#define CLEF_DE_CRYPTAGE_DECRYPTAGE(nom_de_la_clef,diviseur_de_la_clef) \
DIVI(GvalDefaut(nom_de_la_clef,CLEF_DE_CRYPTAGE_DECRYPTAGE_NON_DEFINIE),diviseur_de_la_clef)
#define CLEF_DE_CRYPTAGE \
CLEF_DE_CRYPTAGE_DECRYPTAGE("ClefCryptage",diviseur_de_cryptage)
#define CLEF_DE_DECRYPTAGE \
CLEF_DE_CRYPTAGE_DECRYPTAGE("ClefDecryptage",diviseur_de_decryptage)
/* Clef de cryptage/decryptage qui ne peut-etre entree via 'GET_ARGUMENT_I(...)' afin de ne */
/* pas apparaitre dans les histories. Pour la meme raison, les variables '$ClefShufBytes?' */
/* ne devront pas etre definies dans un fichier, ni etre definies interactivement, mais */
/* uniquement via : */
/* */
/* secret ClefShufBytesC */
/* secret ClefShufBytesD */
/* */
/* sous '$CSH', ce qui ne laisse donc aucune trace... */
/* */
/* Pour des raisons de confidentialite liees a la programmation "secrete" de */
/* 'v $Falias_fcrypte ClefCryptage' et de 'v $Falias_fdecrypte lefDecryptage' le */
/* 20050108100540 il y a eu les changements de nom suivant : */
/* */
/* ClefShufBytesC ---> ClefCryptage */
/* ClefShufBytesD ---> ClefDecryptage */
/* */
#define PREMIER_OCTET \
VALEUR_MINIMALE_DANS_UN_OCTET
#define DERNIER_OCTET \
VALEUR_MAXIMALE_DANS_UN_OCTET
/* Definitions introduites le 20041208140648 apres que {PREMIER_OCTET,DERNIER_OCTET} */
/* aient ete supprimees dans 'v $xil/defi_K2$vv$DEF' comme etant redondantes avec les */
/* definitions {VALEUR_MINIMALE_DANS_UN_OCTET,VALEUR_MAXIMALE_DANS_UN_OCTET}. Elles */
/* permettent ainsi de ne pas changer ce qui suit et de ne pas rallonger certaines lignes... */
#define TABLE_DES_PERMUTATIONS \
COND(EST_VRAI(c_est_l_operation_directe) \
,table_des_permutations_directes \
,table_des_permutations_inverses \
) \
/* Definition introduite le 20041207143217... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P E R M U T A T I O N " A L E A T O I R E " E T R E V E R S I B L E D ' O C T E T S : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Logical,INIT(editer_la_table_des_permutations,EDITER_LA_TABLE_DES_PERMUTATIONS));
/* Faut-il seulement editer la table des permutations ('VRAI') ou bien faire un */
/* cryptage/decryptage ('FAUX') ? */
DEFV(Logical,INIT(c_est_l_operation_directe,C_EST_L_OPERATION_DIRECTE));
/* Est-ce l'operation directe dite "chiffrage" ('VRAI') ou l'operation inverse dite */
/* "dechiffrage" ('FAUX') ? */
DEFV(Logical,INIT(generer_une_operation_neutre,GENERER_UNE_OPERATION_NEUTRE));
/* Doit-on faire du cryptage/decryptage ('FAUX') ou bien une operation neutre ('VRAI'), */
/* c'est-a-dire ne pas crypter/decrypter ? Ceci fut introduit le 20070306093201.... */
DEFV(Int,INIT(diviseur_de_cryptage,DIVISEUR_DE_CRYPTAGE));
DEFV(Int,INIT(diviseur_de_decryptage,DIVISEUR_DE_DECRYPTAGE));
/* Diviseurs des clefs de cryptage/decryptage (introduit le 20041204115821) compatibles */
/* avec 'v $Falias_decrypte DiViSeUr'. */
DEFV(Int,INIT(clef_de_cryptage_decryptage,UNDEF));
/* Clef de cryptage/decryptage qui ne peut-etre entree via 'GET_ARGUMENT_I(...)' afin de ne */
/* pas apparaitre dans les histories. Pour la meme raison, les variables '$ClefShufBytes?' */
/* ne devront pas etre definies dans un fichier, ni etre definies interactivement, mais */
/* uniquement via : */
/* */
/* secret ClefShufBytesC */
/* secret ClefShufBytesD */
/* */
/* sous '$CSH', ce qui ne laisse donc aucune trace... */
/* */
/* Pour des raisons de confidentialite liees a la programmation "secrete" de */
/* 'v $Falias_fcrypte ClefCryptage' et de 'v $Falias_fdecrypte lefDecryptage' le */
/* 20050108100540 il y a eu les changements de nom suivant : */
/* */
/* ClefShufBytesC ---> ClefCryptage */
/* ClefShufBytesD ---> ClefDecryptage */
/* */
/*..............................................................................................................................*/
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("editer=",editer_la_table_des_permutations);
GET_ARGUMENT_N("crypter_decrypter=",editer_la_table_des_permutations);
GET_ARGUMENT_L("directe=""crypter=""crypte=""cryptage=",c_est_l_operation_directe);
GET_ARGUMENT_N("inverse=""decrypter=""decrypte=""decryptage=",c_est_l_operation_directe);
GET_ARGUMENT_L("neutre=",generer_une_operation_neutre);
GET_ARGUMENT_N("cryptage_decryptage=",generer_une_operation_neutre);
GET_ARGUMENT_I("diviseurC=""dc=",diviseur_de_cryptage);
GET_ARGUMENT_I("diviseurD=""dd=",diviseur_de_decryptage);
)
);
/* Le 'GET_ARGUMENTS_(...)' est mis avant la validation de 'clef_de_cryptage_decryptage' */
/* afin de permettre de faire des 'use's et des 'suse's de cette commande... */
EGAL(clef_de_cryptage_decryptage
,COND(EST_VRAI(c_est_l_operation_directe)
,CLEF_DE_CRYPTAGE
,CLEF_DE_DECRYPTAGE
)
);
/* Entree de la clef de cryptage/decryptage. Le 'FRA?(...)' a ete introduit le */
/* 20041204115821 et est "en phase" avec 'v $Falias_decrypte DiViSeUr'... */
Test(IFOU(IL_FAUT(generer_une_operation_neutre)
,IFET(IL_NE_FAUT_PAS(generer_une_operation_neutre)
,IFNE(clef_de_cryptage_decryptage,CLEF_DE_CRYPTAGE_DECRYPTAGE_NON_DEFINIE)
)
)
)
Bblock
DEFV(Int,INIT(index,UNDEF));
DEFV(Int,INIT(index_de_permutation,PREMIER_OCTET));
DEFV(Logical,DTb1(table_de_validation_des_permutations,NOMBRE_D_OCTETS_DIFFERENTS));
DEFV(Int,DTb1(table_des_permutations_directes,NOMBRE_D_OCTETS_DIFFERENTS));
DEFV(Int,DTb1(table_des_permutations_inverses,NOMBRE_D_OCTETS_DIFFERENTS));
/* Allocation des vecteurs destines a gerer les permutations... */
DoIn(index,PREMIER_OCTET,DERNIER_OCTET,I)
Bblock
EGAL(ITb1(table_de_validation_des_permutations,INDX(index,PREMIER_OCTET)),INVALIDE);
EGAL(ITb1(table_des_permutations_directes,INDX(index,PREMIER_OCTET)),index);
EGAL(ITb1(table_des_permutations_inverses,INDX(index,PREMIER_OCTET)),index);
/* Initialisation du processus de generation des permutations... */
Eblock
EDoI
DoIn(index,PREMIER_OCTET,DERNIER_OCTET,I)
Bblock
DEFV(Logical,INIT(chercher_une_permutation,VRAI));
DEFV(Int,INIT(compteur_de_detection_de_bouclage,UN));
EGAL(index_de_permutation
,COND(IL_NE_FAUT_PAS(generer_une_operation_neutre)
,MODS(REST(MUL2(clef_de_cryptage_decryptage,ADD2(index_de_permutation,I))
,NOMBRE_D_OCTETS_DIFFERENTS
)
,PREMIER_OCTET
,DERNIER_OCTET
)
,index
)
);
/* Index courant de permutation : mais n'est-il pas deja utilise ? */
Tant(EST_VRAI(chercher_une_permutation))
Bblock
Test(IFLE(compteur_de_detection_de_bouclage,NOMBRE_D_OCTETS_DIFFERENTS))
Bblock
INCR(compteur_de_detection_de_bouclage,I);
Test(EST_VALIDE(ITb1(table_de_validation_des_permutations,INDX(index_de_permutation,PREMIER_OCTET))))
Bblock
EGAL(index_de_permutation
,MODS(ADD2(index_de_permutation,I)
,PREMIER_OCTET
,DERNIER_OCTET
)
);
/* L'entree courante est deja occupe, passage a la suivante... */
Eblock
ATes
Bblock
EGAL(chercher_une_permutation,FAUX);
/* Une entree inoccupee a ete trouvee... */
EGAL(ITb1(table_de_validation_des_permutations,INDX(index_de_permutation,PREMIER_OCTET)),VALIDE);
EGAL(ITb1(table_des_permutations_directes,INDX(index_de_permutation,PREMIER_OCTET)),index);
EGAL(ITb1(table_des_permutations_inverses,INDX(index,PREMIER_OCTET)),index_de_permutation);
/* Et on l'occupe... */
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la recherche de l'index de permutation semble boucler");
/* Ceci a ete introduit le 20041204184717... */
Eblock
ETes
Eblock
ETan
Eblock
EDoI
Test(IL_FAUT(editer_la_table_des_permutations))
Bblock
DEFV(Int,INIT(nombre_de_chiffres_utiles,NOMBRE_DE_CHIFFRES_DECIMAUX(NOMBRE_D_OCTETS_DIFFERENTS)));
/* Afin de garantir une belle tabulation... */
/* */
/* Avant le 20060104163621, on trouvait ici : */
/* */
/* TRPU(POSI(LO1X(NOMBRE_D_OCTETS_DIFFERENTS))) */
/* */
/* comme nombre de chiffres... */
DoIn(index,PREMIER_OCTET,DERNIER_OCTET,I)
Bblock
CAL3(Prme4("%0*d --> %0*d\n"
,nombre_de_chiffres_utiles
,index
,nombre_de_chiffres_utiles
,ITb1(TABLE_DES_PERMUTATIONS,INDX(index,PREMIER_OCTET))
)
);
Eblock
EDoI
Eblock
ATes
Bblock
DEFV(Int,INIT(caractere_courant,K_UNDEF));
/* Octet courant. ATTENTION, on utilise le type 'Int' et non pas 'Char' a */
/* cause de de l'usage qui sera fait ci-apres de 'GetcharQ(...)', et ce afin que le test */
/* de fin de fichier fonctionne correctement... */
Tant(GetcharQ(caractere_courant))
Bblock
/* Le caractere courant de l'entree courante est recupere ; et on boucle */
/* sur cette recuperation tant que l'on n'est pas au bout du fichier. */
CALS(Putchar(ITb1(TABLE_DES_PERMUTATIONS,INDX(caractere_courant,PREMIER_OCTET))));
/* Enfin, cryptage ou decryptage... */
Eblock
ETan
Eblock
ETes
Eblock
ATes
Bblock
Test(EST_VRAI(c_est_l_operation_directe))
Bblock
PRINT_ERREUR("la clef de cryptage 'ClefCryptage' n'a pas ete definie (elle doit l'etre via 'secret')");
Eblock
ATes
Bblock
PRINT_ERREUR("la clef de decryptage 'ClefDecryptage' n'a pas ete definie (elle doit l'etre via 'secret')");
Eblock
ETes
Eblock
ETes
RETU_Commande;
Eblock
ECommande