Forum Freedom-IP VPN

Didier-T

Contributeurs Confirmés

Lieu : Argenteuil

Inscription : 2014-02-01

Messages : 323

[Linux & Windows ] [Python] Bibliothèque pour l'API Freedom-IP

from freedom_ip_lib import freedom

Dernière modification par Didier-T (2015-04-01 14:55:43)

Polizei

Membres de confiance

Inscription : 2013-12-27

Messages : 403

Re : [Linux & Windows ] [Python] Bibliothèque pour l'API Freedom-IP

À noter que a priori le token possède maintenant une variable "heure" qui est réglable de 1 à 24 correspondant à la durée en heure(s) de la validité du token.

Mais il me semble que ta bibliothèque gère le token indépendamment de sa durée de vie (s’il n’éxiste pas : il le créé, s’il éxiste déjà : il utilise, s’il n’est plus valable : il en créé un autre...) et donc il n’y a rien besoin de modifier à mes yeux pour l’instant.
Edit : du moins c’est ce comportement qu’on observe sur ta traduction/version Windows...

Merci pour ton active participation en passant 

Didier-T

Contributeurs Confirmés

Lieu : Argenteuil

Inscription : 2014-02-01

Messages : 323

Re : [Linux & Windows ] [Python] Bibliothèque pour l'API Freedom-IP

Bonjour Polizei,
en fait je n'y avais pas fait attention.
Par contre l'a bibliothèque regarde l'âge du token (si existant), pour savoir s'il faut en générer un nouveau.

Les codes sont à jour.

A+,
Didier.

Edit : Maintenant les scripts fonctionnes sous Windows et Linux

Dernière modification par Didier-T (2015-03-11 18:16:56)

Didier-T

Contributeurs Confirmés

Lieu : Argenteuil

Inscription : 2014-02-01

Messages : 323

Re : [Linux & Windows ] [Python] Bibliothèque pour l'API Freedom-IP

#! /usr/bin/python
# -*- coding: utf-8 -*-
# Par Didier-T pour les utilisateurs de Freedom-IP

########################################################################
#                                                                      #
#                            UTILISATION                               #
#                                                                      #
########################################################################
#                                                                      #
# from freedom_ip_lib import freedom                                   #
#                                                                      #
# user="Identifiant VPN"                                               #
# password="Mot de passe VPN"                                          #
# path="Chemin de stockage clef VPN" (nom généré automatiquement)      #
# Time="temp de validité du Token entre 1 et 24 heure(s)"              #
#                                                                      #
# Token=freedom(user, password, path, Time)                            #
#                                                                      #
# IsLogged=Token.IsLogged()                                            #
# FairUse=Token.FairUse()                                              #
# DNSConfig=Token.DNSConfig()                                          #
# Dons=Token.Dons()                                                    #
# StarPass=Token.StarPass()                                            #
# ProxyRules=Token.ProxyRules()                                        #
# HTTPSEverywhere=Token.HTTPSEverywhere()                              #
# GetAllServersInfos=Token.GetAllServersInfos()                        #
#                                                                      #
########################################################################

########################################################################
#                                                                      #
#                   UTILISATION FONCTION TEST API                      #
#                                                                      #
########################################################################
#                                                                      #
# python freedom_ip_lib .py user password                               #
#                                                                      #
########################################################################

import urllib, urllib2, os, time, platform, json
import marshal
from re import search, compile
try:
    import ssl
except:
    pass

class freedom():
    def __init__(self, user, password, path, vtime=1):
        self.user=user
        self.password=password
        self.path=path
        self.vtime=int(vtime)
        self.token=None
        self.delais=self.vtime*3600
        self.file_token=self.path+"/"+self.user+".token"
        # Si le fichier Freedom.token existe, on regarde l'heure de sa dernière modification
        if os.path.isfile(self.file_token):
            self.dernier_token=int(os.path.getmtime(self.file_token))
        else:
            self.dernier_token=0
        self._token("ok")

    def _past(self, url, args):
        params = urllib.urlencode(args)
        req = urllib2.Request(url, params)
        if platform.system() != 'Linux':
            gcontext = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
            response = urllib2.urlopen(req, context=gcontext)
        else:
            response = urllib2.urlopen(req)
        data=json.loads(response.read())
        return data

    def _token(self, status):
        print("[\033[33mINFO\033[0m] Récupération clef Token")
        token={}
        def _recherchetoken(token):
            #token=eval(token)
            if token['created_token']=="null":
                expire=compile("expire on (.*)").search(token['reason']).group(1)
                self.dernier_token=int(time.mktime(time.strptime(expire, "%d/%m/%Y at %H:%M:%S")))-self.delais
                return token['token']
            else:
                return token['created_token']

        # si le fichier Freedom-IP.token a été modifier il y a 1 heure ou plus demande d'un nouveau Token
        if int(time.time())-self.dernier_token >= self.delais or status=="bad":
            if status=="bad":
                print("[\033[33mINFO\033[0m] Demande nouvelle clef Token suite erreur")
            else:
                print("[\033[33mINFO\033[0m] Demande nouvelle clef Token suite fin de validité")
            token=self._past('https://freedom-ip.com/api/login.fip', {'username':self.user, 'password':self.password, 'expire_long':self.vtime})
            self.token=_recherchetoken(token)
            self.dernier_token=int(time.time())
            fiche = open(self.file_token, "wb")
            marshal.dump(token, fiche)
            fiche.close()

        else:
            if self.token is None:
                fiche = open(self.file_token, "rb")
                try:
                    token=marshal.load(fiche)
                except:
                    print("[\033[31mFAIL\033[0m] Fichier Token incorrecte")
                    print("[\033[33mINFO\033[0m] Création d'un nouveau fichier Token")
                    self._token("bad")
                    print("[\033[32m OK \033[0m] Nouvelle clef Token obtenu")
                    return
                self.token=_recherchetoken(token)
                fiche.close()

        print("[\033[32m OK \033[0m] clef Token obtenu")

    def _info(self, recherche):
        print("[\033[33mINFO\033[0m] Demande "+recherche)

        if recherche=="IsLogged" or recherche=="GetFairUse" or recherche=="GetDNSConfig":
            response=self._past('https://freedom-ip.com/api/vpn.fip', {'token':self.token, 'method':recherche})
        elif recherche=="GetDons" or recherche=="GetStarPass":
            response=self._past('https://freedom-ip.com/api/users.fip', {'token':self.token, 'method':recherche})
        elif recherche=="GetProxyRules" or recherche=="GetHTTPSEverywhere":
            response=self._past('https://freedom-ip.com/api/proxy.fip', {'token':self.token, 'method':recherche})
        elif recherche=="GetAllServersInfos":
            response=self._past('https://freedom-ip.com/api/servers.fip', {'token':self.token, 'method':recherche})

        return response

    def _verif(self, informations, recherche):
        try:
            status=informations["status"]
        except:
            status="ok"
        if status=="ok":
            print("[\033[32m OK \033[0m] "+recherche)
            return informations
        else:
            print("[\033[31mFAIL\033[0m] Demande d'un nouveau Token")
            self._token(status)
            response=self._info(recherche)
            print("[\033[32m OK \033[0m] "+recherche)
            return response


    def IsLogged(self):
        response=self._info("IsLogged")
        return self._verif(response, "IsLogged")

    def FairUse(self):
        response=self._info("GetFairUse")
        return self._verif(response, "GetFairUse")

    def DNSConfig(self):
        response=self._info("GetDNSConfig")
        return self._verif(response, "GetDNSConfig")

    def Dons(self):
        response=self._info("GetDons")
        return self._verif(response, "GetDons")

    def StarPass(self):
        response=self._info("GetStarPass")
        return self._verif(response, "GetStarPass")

    def ProxyRules(self):
        response=self._info("GetProxyRules")
        return self._verif(response, "GetProxyRules")

    def HTTPSEverywhere(self):
        response=self._info("GetHTTPSEverywhere")
        return self._verif(response, "GetHTTPSEverywhere")

    def GetAllServersInfos(self):
        response=self._info("GetAllServersInfos")
        return self._verif(response, "GetAllServersInfos")

def arbres(jstr):
    tableau=[]

    def decoupage(nom, valeur):
        if type(valeur)==list:
            nb=0
            for x in valeur:
                decoupage(nom+"["+str(nb)+"]", x)
                nb+=1
        elif type(valeur)==dict:
            for x in valeur:
                decoupage(nom+"["+x+"]", valeur[x])
        else:
            try:
                tableau.append(nom+"="+valeur)
            except:
                tableau.append(nom+"="+str(valeur))

    if type(jstr)==list:
        nb=0
        for x in jstr:
            decoupage("["+str(nb)+"]", x)
            nb+=1
    elif type(jstr)==dict:
        for x in jstr:
            decoupage("["+x+"]", jstr[x])
    else:
        tableau.append(str(jstr))

    return tableau




def _test():
    import sys

    class Timer(object):
        def start(self):
            if hasattr(self, 'interval'):
                del self.interval
            self.start_time = time.time()
        def inter(self):
            if hasattr(self, 'start_time'):
                self.interval = time.time() - self.start_time
        def stop(self):
            if hasattr(self, 'start_time'):
                self.interval = time.time() - self.start_time
                del self.start_time

    timer = Timer()
    path=os.path.dirname(os.path.abspath(__file__))
    user=str(sys.argv[1])
    password=str(sys.argv[2])

    timer.start()
    api=[]
    Token=freedom(user, password, path, 1)
    list_api=['IsLogged','FairUse','DNSConfig','Dons','StarPass','StarPass','ProxyRules','HTTPSEverywhere','GetAllServersInfos']
    api.append(Token.IsLogged())
    api.append(Token.FairUse())
    api.append(Token.DNSConfig())
    api.append(Token.Dons())
    api.append(Token.StarPass())
    api.append(Token.ProxyRules())
    api.append(Token.HTTPSEverywhere())
    api.append(Token.GetAllServersInfos())

    timer.inter()
    t1=timer.interval

    for x in range(0,len(api)):
        print("\033[41mArbre retour fonction \033[1m{}()\033[0;41m :\033[0m".format(list_api[x]))
        print('\n'.join(arbres(api[x])))
        print('\n')

    print("\033[41mChronomètre :\033[0m")
    timer.stop()
    print 'Temp consultation API :', t1
    print 'Temp exploration arbres :', timer.interval-t1
    print 'Temp consultation API + exploration arbres :', timer.interval


if __name__ == '__main__':
    _test()

Dernière modification par Didier-T (2015-04-01 14:56:24)