Sujet Précédent Sujet Suivant

Générer fenètre d'authentification répertoire protéger

Fermé
DWIG Messages postés 6 Date d'inscription jeudi 9 mai 2013 Statut Membre Dernière intervention 11 mai 2013 - 9 mai 2013 à 22:28
DWIG Messages postés 6 Date d'inscription jeudi 9 mai 2013 Statut Membre Dernière intervention 11 mai 2013 - 11 mai 2013 à 00:52
Bonjour je voudrai protéger un répertoire admin de mon serveur web que j'écris en c SOUS LINUX pour cet faire j'ai utiliser base64.c pour crypter et décrypter les informations seulement je n'arrive pas à générer la fenètre d'authentification au client lorsque cet dernier tente d'accéder a cet répertoire admin
MERCI DE M'AIDER
A voir également:

8 réponses

Réponse 1 / 8
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
9 mai 2013 à 23:52
j'ai utiliser base64.c pour crypter et décrypter les informations
Hum, je demande à voir le niveau de sécurité ^^.
Base 64 ne sert pas à chiffrer mais à coder. Rien à voir. Pour chiffrer, il faut utiliser une fonction de chiffrement (AES, RSA, ...)

Pour le reste, il faut nous en dire plus. Montre ton code pour qu'on puisse voir plus facilement ce que tu veux faire précisément.
0
Réponse 2 / 8
DWIG Messages postés 6 Date d'inscription jeudi 9 mai 2013 Statut Membre Dernière intervention 11 mai 2013
9 mai 2013 à 23:57
voici mon code source
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <time.h>
#define blockSize 1024
#define TAILLE_MAX 500
#define PORT 80
#define ADRSS INADDR_ANY

int sock=-1;
int mutex=0;
struct sockaddr_in sockaddr;

/* *********************Structure de recuperation d'une requete *****************/
struct paquet
{
char requete[32];
char objet[64];
char protocol[16];
};

/* *******************Fonctions de gestion des handlers **************************/
void handlerExit(int sig)
{
printf("\n---Interruption %i---\n\n",sig);
close(sock);
printf("Arret du serveur -------------------------------------[OK]\n\n\n");
exit(0);
}

void handlerGetOutSon(int sig){
wait();
}

/* ********************Gestion de la taille du fichier de log *********************/
void logsize(void)
{

int size=0;
FILE* fichier = NULL;
char chaine[236] = "";
fichier = fopen("log.txt", "r");
if (fichier != NULL)
{
while (fgets(chaine, 256, fichier) != NULL)
{
size+=1;
}
fclose(fichier);
}
if(size>=TAILLE_MAX)
{
fichier=fopen("log.txt","w+");
fclose(fichier);
size=0;
}
mutex=0;
}


/* **********************Verifie si un fichier existe ou pas ********************/
int file_existe(char* chemin)
{
DIR *rep = opendir ("." );
int flag=1;

if (rep != NULL)
{
struct dirent *lecture;

while ((lecture = readdir (rep)))
{
struct stat st;

stat (lecture->d_name, &st);
{

if(strcmp(lecture->d_name,chemin)==0)
{
flag=0;
if(S_ISDIR(st.st_mode))
flag=2;
}
}
}
closedir (rep), rep = NULL;
}
return flag;
}


/* ************************Cherche le fichier index.htm ou index.html dans un dossier ******************/
int index_exist(char chemin[128])
{
char reper[128];
strcpy(reper,chemin);

struct dirent *lecture;
DIR *rep;
int f=0;
char nom[100];
rep = opendir(reper);
if(rep==NULL)
perror("echec\n");
while ((lecture = readdir(rep)))
{
strcpy(nom,lecture->d_name);
printf("%s\n",nom);
if(strcmp(nom,"index.html")==0)
{
f=1;
break;
}
else if (strcmp(nom,"index.htm")==0)
{
f=2;
break;
}
}
closedir(rep);
if(f==1)
return f;
}

/* ***************************Genere le catalogue en html***************************/
int gestion_catalogue(char *chemin, char dossier[120])
{
FILE *fd=fopen(chemin,"x");
if(fd!=NULL)
{
fputs("<html>\n<head><title>catalogue</title></head>\n",fd);
fputs("<body>\n<h3 align=center> LES FICHIERS DISPONIBLES AU TELECHARGEMENT<hr></h3>\n",fd);
fputs("<center><table width=60% heigh=75%><tr><td>Noms des fichiers</td><td>Tailles</td><td>date de mise en ligne</td></tr>",fd);

DIR *rep = opendir (dossier);
if (rep != NULL)
{
char *inter[]={".","..","consult.html","journal.html","index.html","index.htm","page.html"};
int i,j=0;
struct dirent *lecture;
while ((lecture = readdir (rep)))
{

struct stat st;
stat (lecture->d_name, &st);
{
mode_t mode;
mode=st.st_mode;
off_t taille;
taille=st.st_size/1000;

time_t t = st.st_atime;
struct tm tm = *localtime (&t);
char s[32];
strftime (s, sizeof s, "%d/%m/%Y %H:%M:%S", &tm);
char nom[100];
strcpy(nom,lecture->d_name);
for(i=0;i<7;i++)
{
if(strcmp(inter[i],nom)==0)
j=1;
}
if(j==0)
fprintf(fd,"<tr><td><a href=\"%s\">%s</td></a><td>%d Ko</td><td>%s</td></tr>\n",lecture->d_name,lecture->d_name,(int) taille,s);
else
j=0;
}
}
fputs("</center></table></body>\n</body>",fd);

closedir (rep), rep = NULL;
fclose(fd);
}
}
return 0;
}

/* ************************* affiche le journal au format HTML ************************************/
void affiche_log()
{
char chaine[132];
FILE *lg=NULL, *log=NULL;
log=fopen("journal.html","w+");
if(log==NULL) perror("echec\n");
else printf("ouverture du journal OK\n");
fputs("<html>\n<head><title>Server log</title></head>\n<body><center>\n<h1>Journal du serveur</h1></center><hr>\n",log);
fputs("<center>\n<table>",log);
lg=fopen("log.txt","r");
if(lg==NULL)perror("echec\n");
else("Ouverture log ok\n");
do
{
if(strlen(chaine)!=0)
fprintf(log,"<tr><td>%s</td></tr>\n", chaine);

}while(fgets(chaine,100,lg)!=NULL);
fclose(lg);
mutex=0;
fputs("</table>\n</center>\n</body>\n</html>\n",log);
fclose(log);
}

/* ***********************Genere le fichier page d'erreur 404 ************************* */
void page_not_found(int client)
{

int size=50;
write(client,"<html><head><title>Not Found</title></head>\n", size);
write(client,"<body><center><h1> REQUEST NOT FOUND </h1><hr>\n",size);
write(client,"<h3> Oops! la page nexiste plus! </h3>\n",size);
write(client,"</center></body></html>\n",size);
}

/* ***********************Genere le fichier page d'erreur 400 ************************* */
void unrecognized(int client)
{

int size=50;
write(client,"<html><head><title>Non comprise</title></head>\n", size);
write(client,"<body><center><h1 align=center>UNRECOGNIZED REQUEST</h1><hr>\n",size);
write(client,"<h3> oops! demande incomprise!</h3>\n",size);
write(client,"</center></body></html>\n",size);

}

/* ***********************Genere le fichier page d'erreur 403 ************************* */
void non_autorise(int client)
{
int size=50;
write(client,"<html><head><title>unauthorized</title></head>\n", size);
write(client,"<body><center><h1>UNAUTHORIZED REQUEST</h1><hr>\n",size);
write(client,"<h3> oops! Page non autorisee </h3>\n",size);
write(client,"</center></body></html>\n",size);
}

/* ****************************genere la page de statistiques de connexion ********************************/
void genere_statpage(int sockfd)
{
char hostN[20];
char lHostN[256];

FILE *stat=fopen("page.html","w+");
fputs("<html>\n",stat);
fputs("<head><title> Page de statistiques de connexion</title></head>",stat);
fputs("<body><h3 align=center> INFORMATIONS SUR LES HOTES EN COMMUNICATION </h3>",stat);
struct sockaddr_in sockAd;
int lenSockAd=sizeof(sockAd);
char sockInfo[1024];
char sockinfo[1024];

time_t t;
time(&t);
char curTime[32];
sprintf(curTime,"%s", (char *)ctime(&t));

gethostname(hostN,sizeof(hostN));
fprintf(stat,"<center><table border=3><tr><td> SERVEUR</td><td>%s</td></tr><tr><td>DATE DE CONNECTION</td><td>%s</td><tr>\n",hostN,curTime);

getsockname(sockfd,(struct sockaddr*)&sockAd,&lenSockAd);
fprintf(stat,"<tr><td>ID socket client </td><td>%d<td></tr><tr><td>Adresse MAC</td><td>%p</td></tr><tr><td>Adresse IP</td><td>%s</td></tr><tr><td>Port</td><td>%u</td></tr></table></center>\n", sockfd, &sockAd, inet_ntoa(sockAd.sin_addr), ntohs(sockAd.sin_port));
fputs("</body>\n</html>",stat);
fclose(stat);
}


/* **********************envoie un fichier donner au client ************************/
void send_file(int client, char *chemin)
{
FILE *file=fopen(chemin,"rb");
char bufferIOF[1024];
int lg=0;

do
{
lg = fread(bufferIOF,1,1,file);
if(write(client,bufferIOF,lg)<0) perror("IO Error");
}while(lg>0);
fclose(file);
}

/* ************************* CREATION DE LA CONNEXION ************************/
void serveur_ecoute(void)
{
sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0)
perror("Erreur sur la creation de socket!!!");
else
printf("CONNEXION --------------------------------------------[OK]\n\n");

// évite le délai entre deux bind successifs sur le même port
int one=1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))==-1)
perror("erreur");

int dbg0 = bind(sock,(struct sockaddr*)&sockaddr,sizeof(struct sockaddr));
if(dbg0<0)
perror("\t\t\t\tErreur avec le bind()");
else
printf("BINDING ----------------------------------------------[OK]\n\n");


int dbg1 = listen(sock,1);

if(dbg1<0)
perror("\t\t\t\tErreur avec le listen()");
else
printf("LISTENING --------------------------------------------[OK]\n\n\n");
printf("\t\t\tServeur à l'ecoute sur le port 80\n");
}

/* **********************************FONCTION MAIN DU PROGRAMME *****************************/
int main()
{
char choix;
system(" clear");
printf("\n\n\n");
printf("DO YOU WANT TO UPDATE DE SERVER DATA BASE? (Y for yes and any other for no): ");
choix=getchar();
printf("\n\n");
if(choix=='y'||choix=='Y')
{
gestion_catalogue("consult.html",".");
}

else
{
printf("\n\n");
}

//none are work :'(
signal(9,handlerExit);
signal(SIGINT,handlerExit);
signal(SIGKILL,handlerExit);
signal(SIGTERM,handlerExit);
//..
signal(SIGCHLD,handlerGetOutSon);


char* buffer;


sockaddr.sin_family = AF_INET;
sockaddr.sin_port=ntohs(PORT);
sockaddr.sin_addr.s_addr = htonl(ADRSS);

int cpt0=0;

for(cpt0=0;cpt0<sizeof(sockaddr.sin_zero);cpt0++)
{
sockaddr.sin_zero[cpt0]='\0';
}
serveur_ecoute();


FILE *lg=fopen("log.txt", "w+");
fclose(lg);

int i=0;
for(;;)
{
int sizeMax = sizeof(struct sockaddr*);
int sockfd=accept(sock,(struct sockaddr*)&sockaddr,&sizeMax);
if(sockfd<0) perror("accept()");

int pidf;
pidf=fork();
if(pidf<0)
perror("fork()");
else if(pidf==0)
{

buffer=malloc(sizeof(char)*498);
int dbg2=read(sockfd,buffer,498);
if(dbg2<0) perror("read()");
printf("CLIENT::%s\n",buffer);
char *aut;
aut=strstr(buffer,"127.0.0.1");

while(mutex);
mutex=1;
logsize();
while(mutex);
mutex=1;
system("date >>log.txt");
lg=fopen("log.txt","a+");

fprintf(lg,"%s",buffer);
char *adr0, *adr1, *adr2;
struct paquet tr;
adr0 = strtok(buffer," ");
adr1 = strtok(NULL," ");
adr2 = strtok(NULL," ");
sprintf(tr.requete,"%s",adr0);
sprintf(tr.objet,"%s",adr1);
sprintf(tr.protocol,"%s",adr2);

free(buffer);

printf("Request = %s\n",tr.requete);
printf("Target = %s\n",tr.objet);
printf("Protocol = %s\n",tr.protocol);

FILE* myFile;
char chemin[128];
char defaultpage[]="index.html";
char page404[]="404.html";

if(strcmp(tr.requete,"GET")!=0 && strcmp(tr.protocol,"HTTP/1.1")!=0)

{
unrecognized(sockfd);
fputs("REPONSE DU SERVEUR =====================>UNRECOGNIZED REQUEST\n",lg);
fclose(lg);
mutex=0;
}
else
{
int val=0;
sprintf(chemin,"%s",tr.objet);

if(strcmp(chemin,"/")==0)
{
sprintf(chemin,"%s",defaultpage);
}
else
{
sprintf(chemin,"%s",chemin+1);
}
if(strcmp(chemin,"page.html")==0)
{
genere_statpage(sockfd);
}
else
if(strcmp(chemin,"journal.html")==0)
{
if(aut!=NULL)
{
affiche_log();
fputs("REPONSE DU SERVEUR ================OK\n",lg);
fclose(lg);
mutex=0;
}

else
{
non_autorise(sockfd);
fputs("REPONSE DU SERVEUR ================>UNAUTHORIZED REQUEST\n",lg);
fclose(lg);
mutex=0;
val=1;
}
}
int exist = file_existe(chemin);

if(exist==1)
{
if(file_existe(page404)!=0)
{
page_not_found(sockfd);
fputs("REPONSE DU SERVEUR ================>REQUEST NOT FOUND\n",lg);
fclose(lg);
mutex=0;
val=1;
}
else
{
sprintf(chemin,"%s",page404);
fprintf(lg,"REPONSE DU SERVEUR ===========> REQUEST NOT FOUND\n\n\n\n");
fclose(lg);
mutex=0;
}
}
else
if(exist==2)
{
int flag=index_exist(chemin);
if (flag==1)
{
char *newpath="/index.html";
strcat(chemin,newpath);
}
else if(flag==2)
{
char *newpath="/index.htm";
strcat(chemin,newpath);
}
else
{
if(flag==0)
{
char *newpath="/index.html";
char newpah[120];
strcpy(newpah,chemin);
strcat(chemin,newpath);
gestion_catalogue(chemin,newpah);
val=0;
}
}
}
if(val!=1)
{
send_file(sockfd,chemin);
if(val==0)
{
fprintf(lg,"REPONSE DU SERVEUR ============>OK\n\n\n\n");
fclose(lg);
mutex=0;
}
}
close(sockfd);
exit(0);
}
}
else
close(sockfd);
}
close(sock);
return 0;
}
0
Réponse 3 / 8
DWIG Messages postés 6 Date d'inscription jeudi 9 mai 2013 Statut Membre Dernière intervention 11 mai 2013
10 mai 2013 à 00:13
Au fait base64.c m'aurai aider à encoder et décoder les données que le client allait saisir dan la fenètre d'authentification à savoir son loggin et son passwd
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
10 mai 2013 à 13:51
Pourquoi ne pas utiliser un htaccess pour protéger votre répertoire admin ?

D'ailleurs pourquoi ne pas chiffrer les données que le client saisit avant envoi au serveur ? Pourquoi se contenter de coder en base64 (qui n'assure pas du tout la confidentialité) ?
0
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 1 092
Modifié par [Dal] le 10/05/2013 à 14:56
Fiddy : selon ma compréhension, il construit son propre serveur Web, il n'utilise pas un serveur tel que Apache supportant htaccess. Il essaye de répliquer la fonctionnalité d'un serveur supportant ce type de choses.

L'affichage de la fenêtre d'authentification est généré par le client.

Je pense (mais je n'ai jamais fait cela en C), que le serveur doit envoyer au client un code de statut 401, avec un entête "Www-Authenticate".

Un truc du genre : 

HTTP/1.0 401 Authorization Required  
Www-Authenticate: Basic realm="Mes pages secretes"


Pour initier la négociation, ce qui devrait déclencher la demande d'authentification côté client.

RFC 2616, § 10.4.2, § 14.47 : https://datatracker.ietf.org/doc/rfc2616/?include_text=1
et
RFC 2617, qui est consacrée à la question : https://datatracker.ietf.org/doc/rfc2617/?include_text=1

L'échange se fait en clair avec ce procédé, non chiffré mais en revanche encodé en base 64 comme prévu par la RFC 2617. C'est au serveur de gérer la réception de la réponse et l'authentification, et de décoder le base 64.

Page 4 et 5 : 
To receive authorization, the client sends the userid and password,  
   separated by a single colon (":") character, within a base64 [7]  
   encoded string in the credentials.  

(...)  

If the user agent wishes to send the userid "Aladdin" and password  
   "open sesame", it would use the following header field:  

      Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==

Dal
0
Réponse 4 / 8
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 841
10 mai 2013 à 15:48
Très juste. Ce sujet, n'a donc rien à faire dans la partie "C". Je déplace dans une section plus adaptée.
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 8
DWIG Messages postés 6 Date d'inscription jeudi 9 mai 2013 Statut Membre Dernière intervention 11 mai 2013
10 mai 2013 à 19:05
c'est bien cela j'écris mon propre serveur web en c au juste base64.c est utiliser pour encoder les mots de passe que je vais placer dans le fichier .htpasswd se trouvant dans mon répertoire protéger admin

CE QUE JE VOUDRAIS C'EST UN CODE DE STATUT 401 POUR GÉNÉRER LA FENÈTRE D'AUTHENTIFICATION AU CLIENT LORSQUE CET DERNIER VOUDRA ACCÉDER A admin

PAR LA SUITE JE DEVRAIS TROUVER UN CODE QUI VA RÉCUPÉRER LE LOGIN ET PASSWD SAISI PAR LE CLIENT POUR LE COMPARER AVEC LE CONTENU DE .htpasswd
0
Réponse 6 / 8
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 1 092
Modifié par [Dal] le 10/05/2013 à 19:28
As-tu essayé d'envoyer ceci au client ? 

HTTP/1.0 401 Authorization Required    
Www-Authenticate: Basic realm="Mes pages secretes"

D'ailleurs, tes erreurs erreur 404, etc. devraient envoyer de vrais codes d'erreurs, et laisser le soin au navigateur d'afficher ce qu'il doit afficher (au lieu de renvoyer du texte que seul un humain peut lire, et que le navigateur ne comprend pas comme étant une erreur).

Mais, c'est toi qui vois.

J'ai trouvé cela, j'espère que cela te mettra sur la voie :

https://blog.abhijeetr.com/2010/04/very-simple-http-server-writen-in-c.html


Dal
0
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 1 092
Modifié par [Dal] le 10/05/2013 à 19:36
Tu peux aussi voir comment cela est fait dans un serveur complet comme Libmicrohttpd, a priori, c'est dans src/basicauth.c, là http://ftp.gnu.org/gnu/libmicrohttpd/ (récupère le dernier en date à ce jour : libmicrohttpd-0.9.27.tar.gz)

Dal
0
Réponse 7 / 8
DWIG Messages postés 6 Date d'inscription jeudi 9 mai 2013 Statut Membre Dernière intervention 11 mai 2013
10 mai 2013 à 20:12
j'essaye d'envoyer au client
HTTP/1.0 401 Authorization Required
Www-Authenticate: Basic realm="Mes pages secretes"

mais je ne sais pas si je dois utiliser send ou write(client
0
Réponse 8 / 8
DWIG Messages postés 6 Date d'inscription jeudi 9 mai 2013 Statut Membre Dernière intervention 11 mai 2013
11 mai 2013 à 00:52
S'il vous plait j'ai trouver
le code suivant que j'essaie d'implémenter mais ça ne marche pas

static void erreur(int code, reponse_t *rep)
{
switch(code)
{
case 400 :
if(PRINT_ERREUR)
printf("Erreur 400 : Bad Request !\n");
bufstrcpy(&rep->header," 400 Bad Request\r\n",18);
break;
case 401 :
if(PRINT_ERREUR)
printf("Erreur 401 : Unautorized !\n");
bufstrcpy(&rep->header," 401 Unauthorized\r\n",19);
break;
default :
if(PRINT_ERREUR)
printf("Erreur interne : Code d'erreur inconnu !\n");
bufstrcpy(&rep->header,"",0);
}
rep->code = code;
}
if (rep->code == 401){
bufstrcat(output, "WWW-Authenticate: Basic realm=\"serveur de test\"\r\n", 49);

}
0

Discussions similaires

Où faire l'authentification et vérification des Transcash ?
Yoyo -
madmyke -

5 réponses
Authentification d'un ticket transcash
Vans -
Afrikarnak -

5 réponses
Nous limitons la fréquence d’action…
Mimi -
Duieoekend -

7 réponses
Codes connexion Instagram
Cultur2official -
celeste_nji -

4 réponses
cocoland
vbfbr -
fred972 -

6 réponses