Un programme C

Bonjour,
J'ai un programme à compléter mais j'arrive pas à le faire !

voici les questions

+ Ecrivez une fonction expomod qui realise l'exponentiation modulo n d'un entier m à l'exposant i, c'est-a-dire qui calcule mi (mod n).
+ Ecrivez une fonction premier qui verie si un nombre est premier ou non.
+ Utilisez la fonction decoupe fournie pour chirer le message s morceau par morceau. Acher le resultat a l'ecran sous la forme c1; c2; : : : ; ck ou chaque ci est le resulat du chirement du ie morceau de s.
+ Utilisez les fonctions decoupe code et recolle fournies pour dechirer un message code de la forme c1; c2; ... ; ck obtenu a la question precedente et redonne au programme via le clavier.

voila le programme

// Fonctions externes
// Affichage à l'écran et lecture au clavier
#include <stdio.h>
// Fonctions mathématiques : sqrt...
#include <math.h>
// Manipulations des chaînes de caractères
#include <string.h>

/* Définition d'un type chaîne de caractères
* (en fait un tableau de 256 caractères, cf. prochain TD)
* Une fois défini ce type s'utilise comme n'importe quel autre.
* Par exemple : chaine_t s; déclare une variable s de type chaîne de caractères
*/
typedef char chaine_t[256];

/* ==========================================================================
* Fonctions déjà écrites
* ==========================================================================*/

/* lastu <- congruence_un (e, n)
* Congruence de e à un modulo n
*
* Entrées : entiers e, n
* Sorties : entier lastu
*
* Principe : l'algorithme d'Euclide étendu
* (http://fr.wikipedia.org/wiki/Algorithme_d'Euclide_étendu)
*/
int congruence_un( int e, int n)
{
int u = 0;
int v = 1;
int lastu = 1;
int lastv = 0;
int m = n;
int quotient, temp;

while (m != 0)
{
temp = m;
quotient = e / m;
m = e % m;
e = temp;

temp = u;
u = lastu - quotient*u;
lastu = temp;

temp = v;
v = lastv - quotient*v;
lastv = temp;
}

if (lastu < 0) lastu = n+lastu;

return lastu;
}

/* r <- decoupe(s,n)
* Renvoie le tronçon numéro n (le premier tronçon est le numéro 0)
* de 1 caractère de la chaîne s, considéré comme un entier.
* Renvoie -1 si la chaîne fait moins de n+1 tronçons.
*
* Entrées : chaîne de caractères s, entier n
* Sortie : Entier r
*
* Principe :
* (Rappel) un caractère est en fait traité en C comme un entier sur 8 bits,
* c'est-à-dire à valeur entre 0 et 255.
*
* Ici on renvoie ce code appelé "code ASCII" comme un entier
*
*/
int decoupe(chaine_t s, int n)
{
// strlen donne le nombre de caractères dans s
if (n >= strlen(s))
{
// si on demande un tronçon d'indice trop grand, -1
return -1;
} else {
// sinon on renvoie le tronçon d'indice n
// (int) change le type de s[n] de char à int dans l'expression
// fournie à return
return (int) s[n];
}
}

/* r <- decoupe_code(s,n,sep)
* Renvoie l'entier numéro n (le premier est le numéro 0) d'une liste
* d'entiers séparés par le caractère sep
*
* Entrées : chaîne de caractères s, entier n, caractère sep
* Sortie : entier r
*
* Principe :
* sep est un caractère servant à séparer les élemens de la liste représentée
* par s. Par exemple s vaut "192,243,123,43,93" et sep vaut ','
* n indique l'indice de l'élément à renvoyer. Par ex, si n vaut 3, il faut
* renvoyer 43.
*
* On parcourt la chaîne s caractère par caractère en enregistrant les
* occurrences de sep. Quand on a le bon nombre d'occurrence, on crée une
* nouvelle chaîne avec les caractères rencontrés jusqu'à la prochaine
* occurrence de sep. Finalement on transforme la chaîne obtenue en nombre :
* p. ex la chaîne "43" devient l'entier 43.
*/
int decoupe_code(chaine_t s, int n, char sep)
{
// indice du caractère courant dans s
int i = 0;
//
// indice du caractère courant dans nombre
int j = 0;

// nombre d'occurrences de sep rencontrées
int nsep = 0;

// sous-chaîne représentant le n-ième nombre de la liste
chaine_t nombre;

// Tant qu'on n'a pas atteint la fin de la chaîne (caractère nul)
// et qu'on n'a pas trop d'occurrences du séparateur.
while (s[i] != '\0' && nsep <= n)
{
if (s[i] == sep)
{
// Un séparateur de plus
// équivalent à nsep = nsep + 1
++nsep;
} else {
if (nsep == n)
{
// on recopie la sous-chaîne de s située entre le n-ième et le
// n+1-ème séparateur
nombre[j] = s[i];
++j;
}
}
// incrémente i
++i;
}
// Marque la fin de la chaîne t
nombre[j] = '\0';

// Transforme la chaine t en entier et renvoie le résultat
return atoi(nombre);
}

/* s1 <- recolle(s,morceau,n)
* Remet le tronçon d'indice n à sa place
*
* Entrées : chaîne de caractères s, entier morceau, entier n
* Sortie : chaîne de caractères s1
*
* Principe : C'est l'inverse de la fonction decoupe.
*
* Notez que la fonction en C ne renvoie rien. En fait, elle modifie son
* paramètre s. C'est une ``bidouille'' pour surmonter une lacune du C (cf.
* prochain TD).
* Pour utiliser la fonction faites p.ex.
* recolle(message, 43, 3),
* pour mettre le caractère de code ASCII 43 à l'indice 3 de message
*/
void recolle(chaine_t s, int morceau, int n)
{
s[n] = morceau;

// Termine la chaîne de caractères
s[n+1] = '\0';
}

/* ==========================================================================
* Fonctions à écrire
* ==========================================================================*/


/* r <- expomod(m, e, n)
* Exponentiation modulo
* Calcule la puissance e de m, modulo n
*
* Entrées : entiers m, e, n
* Sorties : entier r
*
* Principe (en quelques mots) : ...
*/

// Question 1 : Ecrivez la fonction expomod ici
// ...


/* ... <- est_premier(...)
* Test de primalité
*
* Entrée : ...
* Sortie : ...
*
* Principe (en quelques mots) : ...
*/

// Question 2 : Ecrivez la fonction est_premier ici
// ...

// Fonction principale
int main()
{

// Question 1 : Testez la fonction expomod ici
// ...

// Question 2 : Testez la fonction est_premier ici
// ...


/* En commentaire pour l'instant : décommentez à partir de la question 3

int p, q, n, e, d, phin;
chaine_t message = "Ceci est un message secret";
chaine_t code;
int petit_message = 123;
int c;

printf("Facteurs premiers p et q (entre 16 et 45000 par précaution) :\n");
scanf("%d", &p);

// On pourra vérifier que p et q sont bien premiers :
// while (!est_premier(p))
// {
// printf("p n'est pas premier\n");
// scanf("%d", &p);
// }

scanf("%d", &q);

// Comme pour p...

n = p*q;
printf("n = p*q vaut donc %u\n",n);

phin = (p-1)*(q-1);
printf("et phi(n) = (p-1)*(q-1) vaut %u\n",phin);

printf("Clé publique (e) :\n");
scanf("%d", &e);

printf("Calcul de la clé privée (d)... ");
d = congruence_un(e,phin);
printf("%u\n",d);


// Test de chiffrement
// c = expomod(petit_message,e,n);

// Test de déchiffrement
// ...

// Maintenant on découpe s et on chiffre chaque morceau
// On affiche les morceaux chiffrés à l'écran séparés par des virgules (p.ex.)
// ...

// On lit au clavier la liste qu'on vient d'afficher
// scanf("%s", code);

// On récupère chaque élément, on déchiffre et on recolle
// ...

// A-t-on bien récupéré le message en clair ?

*/

return 0;
}


Si vous pouvez me donner des indication n'hésitez pas ! merci