def run(self): # print("starting........") self.conn, self.re_addr = self.get_request() Auth.server_connect_auth(self.conn) Auth.server_user_auth(self.conn) print("starting........") while True: re_l = self.conn.recv(4) re_len = struct.unpack('i', re_l)[0] dd = self.conn.recv(re_len) ss = json.loads(dd.decode('utf-8'))['total_size'] filename = json.loads(dd.decode('utf-8'))['file_name'] rec_data = 0 total = b'' print(ss) if ss > 0: while rec_data < ss: data = self.conn.recv(4) total = total + data rec_data += len(data) with open(filename, 'wb') as w: w.write(total) self.close_request(self.conn) self.close()
class Client(): def __init__(self, access_key=None, secret_key=None): if access_key and secret_key: self.auth = Auth(access_key, secret_key) else: from conf import ACCESS_KEY, SECRET_KEY self.auth = Auth(ACCESS_KEY, SECRET_KEY) def get(self, path, params=None): verb = "GET" signature, query = self.auth.sign_params(verb, path, params) url = "%s%s?%s&signature=%s" % (BASE_URL, path, query, signature) resp = urllib2.urlopen(url) data = resp.readlines() if len(data): return json.loads(data[0]) def post(self, path, params=None): verb = "POST" print params signature, query = self.auth.sign_params(verb, path, params) url = "%s%s" % (BASE_URL, path) data = "%s&signature=%s" % (query, signature) print data print url resp = urllib2.urlopen(url, data) data = resp.readlines() if len(data): return json.loads(data[0])
def login_as_admin(): LOG.info("login_as_admin") response = Auth().login(APP_URL, ADMIN_USER, ADMIN_PASSWORD) assert response.ok access_token = response.json()["access_token"] yield access_token
def post_login(self, request): #self.response.headers['Access-Control-Allow-Origin'] = '*' #self.response.headers['Access-Control-Allow-Methods'] = '*' #pprint (vars(self)) if Auth.attempt({'email':request.email, 'password':request.password}): return Auth.user().toMessage() else: raise endpoints.NotFoundException('Invalid username or password')
def verify(): email = request.args.get('email') verification_token = request.args.get('token') if not email or not verification_token: return 'No email or token' auth = Auth() response = auth.verify(email=email, verification_token=verification_token) return response['response_text']
def do_login(): if request.method == 'GET': return render_template('login.html') if request.method == 'POST': user = fswww().login(g.form) if not user: flash('Invalid Login') return render_template('login.html') exp = int(time.time()) + 3600 ck = Auth().encrypt_auth_cookie(user, exp) response = make_response(redirect('/')) response.set_cookie(Auth().AUTH_COOKIE_NAME, ck, 3600, exp, '/', None) return response
def edit_user(id): data = data_defaults['user']['edit'] data['action']['url'] = data['action']['url'] % id if request.method == 'GET': data['user'] = Users().get_user(id) return render_template('user_form.html', data=data) if request.method == 'POST': _input = g.form.copy() _input['id'] = id _input['modified_by'] = g.current_user['id'] u = Users().get_user(id) if 'password' in _input and _input['password']: _input['password'] = Auth().password_hash( _input['confirm_password']) else: _input['password'] = u['password'] ok, messages = fswww().validate_user_properties(_input) if not ok: for m in messages: flash(m) return render_template('user_form.html', data={'user': _input}) id = Users().update_user(_input) if id is not False: url = '/users/edit/%d' % id flash('user updated') return redirect(url) flash('unable to update user') return render_template('user_form.html', data={'role': _input})
def login(self, form): u, p = form.get('username'), form.get('password') user = Users().get_by_username(u) print repr(user) if not user or not Auth().authorize_user(user, p): return False return user
def check_authorization(): if request.path[0:7] == '/static': return # FIXME -- api basic auth? if request.endpoint == 'do_login': return ck = request.cookies.get(Auth().AUTH_COOKIE_NAME) if ck is None: return redirect('/login') g.current_user = Auth().decrypt_auth_cookie(ck) if not g.current_user: return redirect('/login')
def get_reservations(self, request): if not Auth.check(): raise endpoints.UnauthorizedException('Please log in.') reservations = Reservation.query() messages = [] for reservation in reservations: messages.append(reservation.toMessage()) return ReservationsMessage(reservations = messages)
def aquireAuthToken(authObj, http): token = "" try: token = authObj.readResponse(authObj.authorizationRequest(http)) except AuthException as e: print("Login mit Zugang {} nicht möglich.".format(e.login)) print("Zugangsdaten erneut eingeben: ") login = input("Login: "******"Passwort: ") aquireAuthToken(Auth(login, password), http) else: http.setToken(token)
def run(self): Auth.client_connect_auth(self.ftpclient) while True: msg = input('>>>:').strip() filepath = (msg) fsize = os.path.getsize(filepath) print(fsize) filename = os.path.split(msg)[1] header = self.makeheader(fsize, filename) self.ftpclient.send(header[0]) self.ftpclient.send(header[1]) with open(msg, 'rb') as f: rec_size = 0 for line in f: self.ftpclient.send(line) time.sleep(0.3) rec_size += len(line) percent = rec_size / fsize p.process(percent) self.ftpclient.close()
def _nsserver(): # 取得namespace列表 result = Auth.identify(Auth, request) if(result['status'] == "success"): user = result['message'] resnamespace = ChannelServer.FindCarNameSpace(user.username) responseObject = { "status": "success", "data": resnamespace, } return jsonify(responseObject), 200 else: return jsonify(result), 401
class Client(): def __init__(self, access_key=None, secret_key=None): if access_key and secret_key: self.auth = Auth(access_key, secret_key) else: pass #from conf import ACCESS_KEY, SECRET_KEY #self.auth = Auth(ACCESS_KEY, SECRET_KEY) def get(self, path, params=None, sigrequest=False): verb = "GET" if sigrequest: signature, query = self.auth.sign_params(verb, path, params) query = self.auth.urlencode(query) url = "%s%s?%s&signature=%s" % (BASE_URL, path, query, signature) else: url = "%s%s?" % (BASE_URL, path) resp = urllib.request.urlopen(url) data = resp.readlines() if len(data): return json.loads(data[0].decode('utf-8')) def post(self, path, params=None): verb = "POST" print (params) signature, data = self.auth.sign_params(verb, path, params) url = "%s%s" % (BASE_URL, path) data.update({"signature":signature}) data = urllib.parse.urlencode(data) data = data.encode('utf-8') resp = urllib.request.urlopen(url, data) data = resp.readlines() if len(data): return json.loads(data[0].decode('utf-8'))
def post(): # get the post data post_data = request.get_json() print(post_data) try: car = CarLoginMgr.CkeckCarIsExist(post_data) if car: auth_token = Auth.encode_auth_token(car.id, car.username) responseObject = resData("success", "車子登錄成功", auth_token.decode()) # 建立namespace ChannelServer.createNamespace(car.username, True) return jsonify(responseObject), 200 else: responseObject = resData("fail", "車子不存在") return jsonify(responseObject), 404 except Exception as e: print(e) responseObject = resData("fail", "Try agsin") return jsonify(responseObject), 500
def test_user_permissions(login_as_admin): LOG.info("test_user_permissions") # Create new user and assign "user" role new_username = "******" new_password = "******" new_user_roles = "user" response = Users().create_user(APP_URL, login_as_admin, new_username, new_password) assert response.ok response_data = response.json() new_user_id = response_data["id"] assert response_data["username"] == new_username assert response_data["roles"] == "user" # Login as the newly created user response = Auth().login(APP_URL, new_username, new_password) assert response.ok response_data = response.json() access_token = response_data["access_token"] # Check the new user can get his own info response = Users().get_current_user(APP_URL, access_token) assert response.ok assert response.json()["username"] == new_username assert response.json()["roles"] == new_user_roles # Check that the newly created user CAN NOT create other users because # it doesn't have admin privileges response = Users().create_user(APP_URL, access_token, "tony", "montana") assert not response.ok # Check that the newly created user CAN NOT delete other users because # it doesn't have admin privileges response = Users().delete_user(APP_URL, access_token, new_user_id) assert not response.ok # Finally, delete the newly created user but this time use the admin account response = Users().delete_user(APP_URL, login_as_admin, new_user_id) assert response.ok
from json import dumps from lib.config import Config from lib.auth import Auth from lib.model.room import Room from lib.model.message import Message app = Flask(__name__) cfg = Config('config.db') app.debug = (__name__ == '__main__') app.config['SECRET'] = cfg.get('socket-key') socketio = SocketIO(app) config = Config('config.db') auth = Auth(config) @app.before_request def log_request(): current_app.logger.debug(request.url) @app.route('/', methods=['GET']) def route_index(): return render_template('index.html') @app.route('/app', methods=['GET']) def route_chat(): return render_template('app.html')
def do_logout(): response = make_response(redirect('/')) response.set_cookie(Auth().AUTH_COOKIE_NAME, '', -1, -1, '/', None) return response
def __init__(self, access_key=None, secret_key=None): if access_key and secret_key: self.auth = Auth(access_key, secret_key) else: pass
def __init__(self, access_key=None, secret_key=None): if access_key and secret_key: self.auth = Auth(access_key, secret_key) else: from conf import ACCESS_KEY, SECRET_KEY self.auth = Auth(ACCESS_KEY, SECRET_KEY)
def get_logout(self, request): Auth.logout() return LogoutResponse(flash = 'Logged Out!!')
response_placement = http.getRequest('placement', params).json()['response'] if 'placement' in response_placement: return response_placement['placement'] else: return None proxies = { "http": "http://proxy.t-online.net:3128", "https": "http://proxy.t-online.net:3128", } http = HttpHandler("http://api.appnexus.com") a = Auth() aquireAuthToken(a, http) filename = "all_site_ALL_categories.csv" worker = AbstractGenericWorker(http) #sites = worker.getAllEntitiesByType('site') sites = worker.getAllEntitiesByRange('site', 300, 400) writer_content = list() count = len(sites) i = 1 all_categories = set()
#!/env/bin/python from flask import Flask, session, escape, render_template, request, url_for, redirect from lib.auth import Auth auth = Auth() app = application = Flask(__name__) #add the secret key from the config #to allow Flask sessions to work app.secret_key = auth.config['app']['secret_key'] @app.route('/') def index(): logged_in = session.get('logged_in') if logged_in: return 'logged in!' else: return '''not logged in. <p><a href="/login">Click here</a> to login.</p> <p><a href="/createaccount">Click here</a> to sign up.</p>''' @app.route('/login', methods=['GET', 'POST']) def login(): if request.method == 'GET': return render_template('login.html') if request.method == 'POST': password = request.form.get('password') email = request.form.get('email') response = auth.login(email, password)
import json from lib.auth import Auth from lib.httpHandler import HttpHandler http = HttpHandler() a = Auth("auth", "here") token = a.readResponse(a.authorizationRequest(http)) http.setToken(token) count = http.getRequestPage(0, "line-item").json()['response']['count'] allAineItems = list() for start_element in range(4300, count, 100): lineItemsNew = http.getRequestPage(start_element, "line-item").json()['response']['line-items'] allAineItems.append(lineItemsNew) allLowLineItems = list() for lineItemArr in allAineItems: for lineItem in lineItemArr: if lineItem['lifetime_budget'] is not None and lineItem['all_stats'] is not None: if float(lineItem['lifetime_budget']) > float(lineItem['all_stats']['lifetime']['revenue'])*2.0: if '7day' in lineItem['all_stats'] and int(lineItem['all_stats']['7day']['imps']) < 7000: allLowLineItems.append(lineItem) elif 'yesterday' in lineItem['all_stats'] and int(lineItem['all_stats']['yesterday']['imps']) < 1000: allLowLineItems.append(lineItem) for lineItem in allLowLineItems:
def test_login(): LOG.info("test_login") response = Auth().login(APP_URL, ADMIN_USER, ADMIN_PASSWORD) LOG.debug(response.json()) assert response.ok