[ANSI C] GET request door passwd prot. proxy naar inet

[xychix]

code:

strcpy(buffer,
    "GET http://foo.nl/home.htm "
    "HTTP/1.0\r\n"
    "Host: foo.nl\r\n\r\n"); 
   
buffer-out = Send( &buffer, "foo.nl", 80 );

met bovenstaande code kan ik een html page ophalen. Ik wil de inhoud van de Send() hier ook nog wel posten maar ik denk niet dat dat erg interessant is.

De GET string zoals hierboven te zien is word naar de server gestuurd en de uitvoer word uitgelezen. Dit werkt naar behoren... alleen op mijn werk moet dit request naar een password protected proxy toe... nu kan ik de machine waar Send() naar connect wel veranderen (en misschien ook de host in de GET string) maar dan moet ik mijn username wachtwoord nog kwijt. Kan iemand mij vertellen hoe ik een correcte GET string opbouw die ik aan een proxy server kan meegeven zodat hij de gevraagde pagina ophaald ?

Ja, uiteraard moet ik ook nog het portnummer van de proxyserver aanpassen, maar dat zijn niet de problemen

Met wat zoeken kwam ik een boel verwijzingen tegen naar fsockopen (php) en ik heb de php.net manual voor fsockopen gelezen
http://www.php.net/manual/en/function.fsockopen.php

inderdaad, hier word naar een proxy verwezen maar enkel naar een niet passwordprotected proxy.

Kan iemand mij vertellen hoe ik mij autenticeer bij de proxy ?

[matthijsln]

Dit staat beschreven in de HTTP standaard:
http://www.rfc-editor.org/rfc/rfc2616.txt
http://www.rfc-editor.org/rfc/rfc2617.txt

Misschien kan je beter CURL of iets dergelijks gebruiken, die ondersteunt ook proxies met wachtwoorden (HTTP Basic authentication).

[xychix]

14.33 Proxy-Authenticate

The Proxy-Authenticate response-header field MUST be included as part
of a 407 (Proxy Authentication Required) response. The field value
consists of a challenge that indicates the authentication scheme and
parameters applicable to the proxy for this Request-URI.

Proxy-Authenticate = "Proxy-Authenticate" ":" 1#challenge

The HTTP access authentication process is described in "HTTP
Authentication: Basic and Digest Access Authentication" [43]. Unlike
WWW-Authenticate, the Proxy-Authenticate header field applies only to
the current connection and SHOULD NOT be passed on to downstream
clients. However, an intermediate proxy might need to obtain its own
credentials by requesting them from the downstream client, which in
some circumstances will appear as if the proxy is forwarding the
Proxy-Authenticate header field.

14.34 Proxy-Authorization

The Proxy-Authorization request-header field allows the client to
identify itself (or its user) to a proxy which requires
authentication. The Proxy-Authorization field value consists of
credentials containing the authentication information of the user
agent for the proxy and/or realm of the resource being requested.

Proxy-Authorization = "Proxy-Authorization" ":" credentials

The HTTP access authentication process is described in "HTTP
Authentication: Basic and Digest Access Authentication" [43] . Unlike
Authorization, the Proxy-Authorization header field applies only to
the next outbound proxy that demanded authentication using the Proxy-
Authenticate field. When multiple proxies are used in a chain, the
Proxy-Authorization header field is consumed by the first outbound
proxy that was expecting to receive credentials. A proxy MAY relay
the credentials from the client request to the next proxy if that is
the mechanism by which the proxies cooperatively authenticate a given
request.

bedankt, eens kijken of dit werk.. ik kan alleen die Authorization wel vullen... alleen ik heb geen flauw ID wat bij Authentication moet komen!

"HTTP Authentication: Basic and Digest Access Authentication" [43]
Door naar bovenstaande string te zoeken kwam ik bij de 2e RFC uit. Tot zover snapte ik het nog... maar uit die 2e kan ik niets wijs worden...

Na wat onvruchtbare pogingen zit ik met deze source:

C:

#include "libhttp.h" 

main(int argc, char* argv[] ) 
{
    char * buffer;
    char * secret;
    char * account;
    int bytes;  

    buffer = (char*)malloc(2048);

    secret = (char*)malloc(2048);
    account = (char*)malloc(2048);
    memset (secret, 0x00, 2048);
    memset (account, 0x00, 2048);

    bytes = sprintf (account, "%s:%s", "user", argv[1]);
    encode_base64 (account, secret, bytes);


    //http://proxy.foo.com:8080
    /* zet een voorbeeld string in de aanvraag */
    sprintf(buffer,
        "GET http://www.rfc-editor.org/rfc/rfc2616.txt "
        "HTTP/1.0\r\n"
        "Host: proxy.foo.com\r\n"
        "Proxy-Authenticate: basic realm=\"Internet Access\r\n\""
        "Proxy-Authorization: Basic %s\r\n"
        "\r\n",secret); 
    
    Sendstr( &buffer, "proxy.foo.com", 8080 ); 
    printf("%s",buffer);
    free(buffer);

    return 0; 
}

[ Voor 25% gewijzigd door xychix op 03-12-2003 09:53 ]

[.oisyn]

Geef eens de prototype van je Sendstr () functie

want wat je nu doet is een pointer naar je buffer meegeven ipv de buffer zelf, en ik betwijfel ten zeerste of dat wel is wat je wilt.

Heb je trouwens je verzonden data al gecontroleerd met een packet sniffer?

[xychix]

.oisyn schreef op 03 december 2003 @ 12:45:
Geef eens de prototype van je Sendstr () functie

want wat je nu doet is een pointer naar je buffer meegeven ipv de buffer zelf, en ik betwijfel ten zeerste of dat wel is wat je wilt.

Heb je trouwens je verzonden data al gecontroleerd met een packet sniffer?

het probleem zit hem eigenlijk in de HTTP headers, als ik namelijk niet door een proxy probeer te connecten maar naar een intranet-site dan werkt hij perfect.

met de huidige aanroep is onderstaand de output:

code:

HTTP/1.0 407 Proxy authorization required
Proxy-agent: Netscape-Proxy/3.53
Date: Wed, 03 Dec 2003 12:26:51 GMT
Proxy-authenticate: basic realm="Internet Access"
Content-type: text/html
Content-length: 271

<HTML><HEAD><TITLE>Proxy authorization required</TITLE></HEAD>
<BODY><H1>Proxy authorization required</H1>
Username authentication is required for using this proxy.
Either your browser does not perform proxy authorization, or your
authorization has failed.
</BODY></HTML>

[ Voor 6% gewijzigd door xychix op 10-12-2003 15:00 ]

[.oisyn]

Ah ok, dan zit daar de fout niet idd...

Je code is overigens niet ISO C. Je gebruikt C++ style comments (// comment), maar dat wordt pas ondersteund sinds C99. En functies zonder returntype zijn in C99 niet meer toegestaan, wel in C89/C90. Jij hebt een beetje een combinatie van beide

[xychix]

Niemand kan mij dus zeggen hoe ik een GET request samenstel dat door een password protected gateway moet worden afgehandeld ??

moet ik een move naar Professional Networking & Servers aanvragen hiervoor ?

want naar het lijkt gaat het enkel om headers van de html request ?!?

of zou er nog wel meer programmeren bij komen kijken ??

[PommeFritz]

Volgens mij zit je HTTP reply headers in je HTTP request te gebruiken, dat gaat niet werken. Tevens voor zover ik weet moet de 'secrect' (je username en password) niet als plain tekst maar base-64 encoded worden doorgegeven. Sorry heb geen tijd meer om precieze HTTP header voor je op te zoeken maar dat moet wel ergens in 1 van die 2 RFCs staan...

edit: ik had je encode_base64 niet gezien, dat was er al dus...

[ Voor 14% gewijzigd door PommeFritz op 04-12-2003 09:01 . Reden: lezen.... ]

[farlane]

xychix schreef op 03 december 2003 @ 09:07:
[...]

C:

    secret = (char*)malloc(2048);
    account = (char*)malloc(2048);

    bytes = sprintf (account, "%s:%s", "user", argv[1]);
    encode_base64 (account, secret, bytes);

    /* zet een voorbeeld string in de aanvraag */
    sprintf(buffer,
        "GET http://www.rfc-editor.org/rfc/rfc2616.txt "
        "HTTP/1.0\r\n"
        "Host: proxy.foo.com\r\n"
        "Proxy-Authenticate: basic realm=\"Internet Access\r\n\""
        "Proxy-Authorization: Basic %s\r\n"
        "\r\n",secret); 

Waarom heb ik het idee dat je in je encode_base64 de twee buffers account en secret hebt omgedraait ?

[xychix]

farlane schreef op 04 december 2003 @ 00:41:
[...]


Waarom heb ik het idee dat je in je encode_base64 de twee buffers account en secret hebt omgedraait ?

netjes opgemerkt... toch niet waar die base64_encode is een zelfbouw functie van hier en zo is nou eenmaal de func. definitie... weird... k weet't

PommeFritz schreef op 03 december 2003 @ 23:52:
Volgens mij zit je HTTP reply headers in je HTTP request te gebruiken, dat gaat niet werken. Tevens voor zover ik weet moet de 'secrect' (je username en password) niet als plain tekst maar base-64 encoded worden doorgegeven. Sorry heb geen tijd meer om precieze HTTP header voor je op te zoeken maar dat moet wel ergens in 1 van die 2 RFCs staan...

Dank voor je uitleg.. maar idd zover ben ik nu NET ik kan die headers alleen niet vinden

[ Voor 43% gewijzigd door xychix op 04-12-2003 06:52 ]

[xychix]

-

[ Voor 137% gewijzigd door xychix op 08-12-2003 06:56 ]

[xychix]

KICK

kan dan niemand mij vertellen hoe ik door een proxy (pass. protected) kan communiceren (http)?

Ik zal nog maar eens een zo simpel mogelijk proggie openrukken van source forge....

Een andere optie is het volgende:
een lokaal draaiende proxy die requests aanneemt en deze samen met het password uit het config filetje doorgeeft aan de echt proxy....

[ Voor 30% gewijzigd door xychix op 08-12-2003 10:22 ]

[PommeFritz]

Probeer het eens met Mozilla en bekijk de live HTTP headers... of gebruik een netwerk snooper om te kijken hoe een web browser het doet.... ?

[xychix]

PommeFritz schreef op 08 december 2003 @ 12:05:
Probeer het eens met Mozilla en bekijk de live HTTP headers... of gebruik een netwerk snooper om te kijken hoe een web browser het doet.... ?

Ook dat heb ik al gedaan..

maar als ik een base64 bereken over user:pass komt er heel wat anders uit dan dat ik in de sniffer zie langskomen van IE6.0

De code waarmee het ZOU moeten lukken.....

C:

int _stdcall httpget(char ** response, char * url, char* host, unsigned short port, int typereq)
{
    char * buffer;
    char * secret;
    int getlength;

    getlength = 128 + strlen(url) + strlen(host);

    secret = (char*) malloc(1024);
    encode_base64 ("user:pass", secret, 15);
    printf("%s",secret);


    buffer = (char *)malloc (getlength);
//http://proxy.foo:8080
    sprintf(buffer,
        "GET %s "
        "HTTP/1.1\r\n"
        "Proxy-Connection: Keep-Alive\r\n"
        "Proxy-Authorization: %s\r\n"
        "Host: proxy.foo\r\n"
        "\r\n", url, secret); 
    
    printf("%s",buffer);

    Sendstr( &buffer, "proxy.foo", 8080 ); 
    printf("%s",buffer);

    *response = strdup(buffer);
    free(buffer);

    return(0); 
}

[ Voor 9% gewijzigd door xychix op 08-12-2003 12:24 ]

[matthijsln]

xychix schreef op 08 december 2003 @ 12:23:
[...]

Ook dat heb ik al gedaan..

maar als ik een base64 bereken over user:pass komt er heel wat anders uit dan dat ik in de sniffer zie langskomen van IE6.0

C:

        "Proxy-Authorization: %s\r\n"

Doe hier ipv %s dan eens de base64 encoded user:pass van IE. Als dat wel werkt weet je dat het aan je base64 encoding ligt of niet (lijkt me wel als het verschillend is als IE).

Zie RFC2045 6.8 voor base64 of post je code hier...

[4VAlien]

Misschien is de CURL library een optie? die heeft een hoop netwerk functies waaronder proxy.

[xychix]

4VAlien schreef op 08 december 2003 @ 12:39:
Misschien is de CURL library een optie? die heeft een hoop netwerk functies waaronder proxy.

ik kan geen leesbare C code daarvan vinden, dan kon ik het daaruit jatten...


gelukt

C:

#include <sys/types.h>


#ifdef   UNIX                            /* UNIX/LINUX only. */
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <netdb.h>
#else
    #include <winsock.h>
    #include <windows.h>
#endif                                 

#include <string.h>
#include <time.h>
#include <stdarg.h>

#include <stdio.h> 
#include <string.h> 
#include <ctype.h>

#include "log.h"
#include "base64.h" 

#define DATALEN 1024
#define SLEEPTIME 500


char * Sendstr( char **ioBuffer, char * IPAdres, unsigned short Portnr ); 
int sendall(int s, char *buf, int len);


char * Sendstr( char **ioBuffer, char *IPAdres, unsigned short Portnr ) 
{ 
    /*Author: Declaratie van de benodigde Variables */
    char * Buffer;
    char * pBuffer;
    SOCKET Socket; 
    int rc;
    int bufferlen;

#ifdef UNIX
#else
    WSADATA WSAData; 
#endif
    struct sockaddr_in HostAddress; 
    LPSTR lpszAscii; 
    struct hostent *    phost       = 0;


#ifdef UNIX
#else
    /*Author Windows only */
    if( ( rc = WSAStartup( 2, &WSAData) ) != 0 )
    {
        logexit("libhttp.c","Sendstr",23,"WSAStartup failed rc=%d\n",rc);
    }
#endif


    /*Author zet een socket */
    if( ! (Socket = socket( AF_INET, SOCK_STREAM, 0 ) ) )
    {
        perror("socket");
    }

    if( ! (phost = gethostbyname (IPAdres) ) )
    {
        perror("gethostbyname");
    }


    HostAddress.sin_family = AF_INET; 
    HostAddress.sin_port = htons(Portnr); /* Netwerk adressering gebruiken  */
    lpszAscii = IPAdres; 
    HostAddress.sin_addr.s_addr = ((struct in_addr *)(phost->h_addr))->s_addr;


    if( (rc = connect( Socket, (SOCKADDR *)&HostAddress, sizeof( struct sockaddr_in ) ) ) != 0 )
        perror("connect");

    /*Author: De ingevoerde data versturen */

    if( (rc = sendall( Socket, *ioBuffer, strlen(*ioBuffer) ) ) != 0 )
        perror("send");
    
    /*Author: De ingevoerde data is verstuurd, we kunnen nu deze geheugenruimte vrijgeven */
    /*             Free(*ioBuffer);       */ 
    /* Toch maar aan einde functie gedaan */
    Buffer = (char *)malloc(DATALEN+1);

    memset(Buffer,0x00,DATALEN);
    
    Sleep(SLEEPTIME);

    if( ( rc = recv( Socket, Buffer, DATALEN-1, 0 ) ) < 0)
    {
        perror("recieve");
    }
    
    /*Author: Als er nog bytes over zijn moeten we nog een realloc doen die dat afdekt */
    while(rc > 0)
    {
        /* Aangezien (char *)*pBuffer momenteel niet gebruikt word kunnen we die pointer wel gebruiken */
        /* om het tot nu toe gelezen deel van Buffer te bewaren */
        /* Dit enkel om variabelen te sparen, netter was misschien een nieuwe pointer. */
        pBuffer = strdup(Buffer);

        bufferlen = strlen(Buffer)+DATALEN;

        Buffer = (char *)realloc((void *)Buffer,bufferlen);
        memset(Buffer,0x00,bufferlen);
        strcpy(Buffer,pBuffer);
        free(pBuffer);
        
        if( ( rc = recv( Socket, Buffer+strlen(Buffer), DATALEN-1, 0 ) ) < 0)
        {   
            perror("recieve");
        }
    }

    if( (closesocket( Socket ) ) != 0 )
        perror("close socket");

#ifdef UNIX
#else
    /*Author Windows only */
    WSACleanup(); 
#endif
    free(*ioBuffer);
    *ioBuffer = Buffer;
    return(*ioBuffer);

} 



/* http://www.ecst.csuchico.edu/~beej/guide/net/html/advanced.html#sendall */
/* Functie is overgenomen uit Beej's Guide To Network Programming          */
/* Gewijzigd, er gaat geen int *len meer in maar een int len.              */
int sendall(int s, char *buf, int len)
{
    int total = 0;        /* how many bytes we've sent */
    int bytesleft = len;  /* how many we have left to send */
    int n;

    while(total < len) {
        n = send(s, buf+total, bytesleft, 0);
        if (n == -1) { break; }
        total += n;
        bytesleft -= n;
    }

    return n==-1?-1:0; /* return -1 on failure, 0 on success */
}


int _stdcall httpget(char ** response, char * url, char* host, unsigned short port, int typereq)
{
    char * buffer;
    int getlength;

    getlength = 128 + strlen(url) + strlen(host);
    buffer = (char *)malloc (getlength);

    sprintf(buffer,
        "GET %s "
        "HTTP/1.0\r\n"
        "Host: %s\r\n"
        "\r\n", url, host); 
    
    Sendstr( &buffer, host, port ); 
    /*printf("%s",buffer);*/

    *response = strdup(buffer);
    
    free(buffer);

    return(0); 
}

int _stdcall proxyget(char ** response, char * url, char* host, char* proxy, unsigned short port, char* user, char* passwd, int typereq)
{
    char * buffer;
    char * secret;
    char * account;
    int getlength;

    account = (char *)malloc(2 + strlen(user)+strlen(passwd));
    memset(account,0x00, ( 1 + strlen(user)+strlen(passwd) ) );
    sprintf(account,"%s:%s", user, passwd );
    secret = (char*) malloc(1024);
    memset(secret, 0x00, 1024);
    encode_base64 (account, secret, strlen(account) );


    getlength = 128 + strlen(url) + strlen(host);
    buffer = (char *)malloc (getlength);

    sprintf(buffer,
        "GET %s "
        "HTTP/1.0\r\n"
       /* "Proxy-Authenticate: basic realm=\"Internet Access\"\r\n"  */
        "Proxy-Authorization: Basic %s\r\n" 
        "Proxy-Connection: Keep-Alive\r\n"
        "Host: %s\r\n"
        "\r\n", url, secret, host); 

    Sendstr( &buffer, proxy, port ); 

    *response = strdup(buffer);
    free(buffer);
    free(secret);
    free(account);

    return(0); 
}

bovenstaande werkt,

in onderstaande functie zit echter nog een memory fout waar hij pas veel later (in sendall ) op klapt

C:

int _stdcall proxypost(char ** response, char * url, char* host, char* proxy, unsigned short port, char* user, char* passwd, int typereq)
{
    char * buffer;
    char * secret;
    char * account;
    char * pParam;
    char * param;
    int getlength;

    account = (char *)malloc(2 + strlen(user)+strlen(passwd));
    memset(account,0x00, ( 1 + strlen(user)+strlen(passwd) ) );
    sprintf(account,"%s:%s", user, passwd );
    secret = (char*) malloc(1024);
    memset(secret, 0x00, 1024);
    encode_base64 (account, secret, strlen(account) );


    getlength = 128 + strlen(url) + strlen(host) /*strlen(secret)*/;
    printf( "getlength %d \n", getlength);

    buffer = (char *)malloc (getlength);

    pParam = strchr(url, '?');
    *pParam = 0x00;
    pParam++;
    param = strdup(pParam);
    pParam--;
    *pParam = '?';
    pParam = 0x00;


    sprintf(buffer,
        "POST %s "
        "HTTP/1.0\r\n"
       /* "Proxy-Authenticate: basic realm=\"Internet Access\"\r\n" */
        "Host: %s\r\n"
        "Proxy-Authorization: Basic %s\r\n" 
        "Proxy-Connection: Keep-Alive\r\n"
        "Content-type: application/x-www-form-urlencoded\r\n"
        "Content-length: %d\r\n"
        "\r\n\r\n%s", url, host,  secret, strlen(param), param); 
    
    

    Sendstr( &buffer, proxy, port ); 

    *response = strdup(buffer);
    free(buffer);
    free(secret);
    free(account);

    return(0); 
}

[ Voor 108% gewijzigd door xychix op 10-12-2003 13:16 ]

[xychix]

kan iemand de fout in bovenstaande functie vinden ??

postproxy...

hij klapt later in sendall bij het (re)allocceren van meer daan 2000 bytes (grofweg) aan buffer.

getproxy werkt wel met grotere hoeveelheden dan 2k

Gevonden

C:

getlength = 128 + strlen(url) + strlen(host) /*strlen(secret)*/; 

128 dekt de lading niet... en ik neem de lengte van url omdat deze (in 2 delen geknipt) mee gegeven wordt.

we zetten een \0 in de url die de mogelijkheid geeft de params uit te lezen, ik moet hier echter ook een copietje van de url zelf trekken... of de \0 laten staan anders gaan de param's 2 keer de buffer in en heb je alsnog een heap overflow.

[ Voor 53% gewijzigd door xychix op 10-12-2003 14:08 ]