def app():
from facebook import Facebook
#Get api key and secret key
facebook = Facebook(API_KEY, API_SECRET)
facebook.auth.createToken()
#Show login window
facebook.login()
#Log in to the window and then press enter
print "After you log in, press enter"
raw_input()
facebook.request_extended_permission('friends_birthday')
raw_input()
facebook.auth.getSession()
info = facebook.users.getInfo([facebook.uid], ['name', 'birthday'])[0]
print info
for attr in info:
print '%s: %s' % (attr, info[attr])
friends = facebook.friends.get()
friends = facebook.users.getInfo(friends[0:100], ['name', 'birthday'])
for friend in friends:
if friend['birthday'] is not None:
print friend['name'], 'has a birthday on', friend['birthday']
else:
print friend['name'], 'has no birthday'
def fb_checking(data):
start = time.time()
try:
facebook_close = Facebook(data).check()
if facebook_close:
email = 'C'
print('C in fb')
return email
else:
email = Facebook(data).get_mail()
print('mail in fb!!!')
return email
except:
pass
end = time.time()
print("----{} seconds---- Facebook".format(end - start))
def _start_fb_session(self):
api_key = settings.FACEBOOK_API_KEY
secret_key = settings.FACEBOOK_SECRET_KEY
app_name = getattr(settings, 'FACEBOOK_APP_NAME', None)
callback_path = getattr(settings, 'FACEBOOK_CALLBACK_PATH', None)
internal = getattr(settings, 'FACEBOOK_INTERNAL', True)
proxy = getattr(settings, 'HTTP_PROXY', None)
facebook = Facebook(api_key,
secret_key,
app_name=app_name,
internal=internal,
callback_path=callback_path,
proxy=proxy)
facebook.auth.createToken()
# Show login window
# Set popup=True if you want login without navigational elements
facebook.login()
# Login to the window, then press enter
print 'After logging in, press enter...'
raw_input()
facebook.auth.getSession()
print 'Session Key: ', facebook.session_key
print 'Your UID: ', facebook.uid
info = facebook.users.getInfo(
[facebook.uid], ['name', 'birthday', 'affiliations', 'sex'])[0]
print 'Hi ', info['name']
return facebook
def on_start(self):
self.facebook = Facebook(FACEBOOK_APP_ID,
permissions=['publish_actions', 'basic_info'])
global modal_ctl
modal_ctl = ModalCtl()
netcheck.set_prompt(modal_ctl.ask_connect)
self.facebook.set_retry_prompt(modal_ctl.ask_retry_facebook)
def parsing_data_tours(self, url, name, session):
fb = Facebook([], self.city)
tour_info = {}
tour_info["name"] = name
header = get_random_user_agent(self.user_agents_list)
try:
#response = requests.get(url, headers={"User-Agent": header})
response = session.get(url,
headers={"User-Agent": header},
timeout=5)
except requests.exceptions.RequestException as e:
print("Ocurrio un error")
try:
header = get_random_user_agent(self.user_agents_list)
response = session.get(url,
headers={"User-Agent": header},
timeout=5)
except:
print("Ocurrio un segundo error")
return tour_info
soup = BeautifulSoup(response.text, "lxml")
tour_info["name"] = core.get_tour_name(soup)
tour_info["telephone"] = core.get_tour_tel(soup)
tour_info["email"] = core.get_tour_mail(soup)
tour_info["website"] = core.get_tour_website(soup)
if tour_info["email"] == "":
if "facebook" in tour_info["website"]:
tour_info["email"] = scrapper_facebook(tour_info["website"])
else:
data = fb.scraping_facebook_tripadvisor(tour_info["name"])
tour_info["email"] = data.get("email", "")
del fb
return tour_info
def handle(self, *args, **options):
"""Load the templates into facebook (probably clear them out beforehand)"""
facebook_obj = Facebook(settings.FACEBOOK_API_KEY,
settings.FACEBOOK_SECRET_KEY)
#blow up all templates
current_templates = facebook_obj.feed.getRegisteredTemplateBundles()
for t in current_templates:
print "Deactivating old bundle #%i ..." % t['template_bundle_id']
facebook_obj.feed.deactivateTemplateBundleByID(
t['template_bundle_id'])
#install templates from our facebook settings file
for bundle in settings.FACEBOOK_TEMPLATES:
name = bundle[0]
one_line_template = bundle[1][0]
short_template = bundle[1][1]
full_template = bundle[1][2]
action_template = bundle[1][3]
response = facebook_obj.feed.registerTemplateBundle(
one_line_template, short_template, full_template,
action_template)
try:
template = FacebookTemplate.objects.get(name=name)
#facebook_obj.feed.deactivateTemplateBundleByID(template.template_bundle_id)
print "Replacing old '%s' bundle ..." % (name.capitalize())
except FacebookTemplate.DoesNotExist:
template = FacebookTemplate(name=name)
print "Loading '%s' bundle ..." % (name.capitalize())
template.template_bundle_id = response
template.save()
def desktop_app():
from facebook import Facebook
# Get api_key and secret_key from a file
fbs = open(FB_SETTINGS).readlines()
facebook = Facebook(fbs[0].strip(), fbs[1].strip())
facebook.auth.createToken()
# Show login window
facebook.login()
# Login to the window, then press enter
print 'After logging in, press enter...'
raw_input()
facebook.auth.getSession()
info = facebook.users.getInfo([facebook.uid], ['name', 'birthday', 'affiliations', 'sex'])[0]
for attr in info:
print '%s: %s' % (attr, info[attr])
friends = facebook.friends.get()
friends = facebook.users.getInfo(friends[0:5], ['name', 'birthday', 'relationship_status'])
for friend in friends:
if 'birthday' in friend:
print friend['name'], 'has a birthday on', friend['birthday'], 'and is', friend['relationship_status']
else:
print friend['name'], 'has no birthday and is', friend['relationship_status']
arefriends = facebook.friends.areFriends([friends[0]['uid']], [friends[1]['uid']])
photos = facebook.photos.getAlbums(friends[1]['uid'])
print photos
def facebook_connect(request, template='socialregistration/facebook.html', extra_context=dict()):
"""
View to handle connecting existing accounts with facebook
"""
fb = Facebook(settings.FACEBOOK_API_KEY, settings.FACEBOOK_SECRET_KEY)
if not fb.check_session(request) \
or not request.user.is_authenticated():
extra_context.update(
dict(error=FB_ERROR)
)
return render_to_response(
template,
extra_context,
context_instance=RequestContext(request)
)
try:
profile = FacebookProfile.all().filter('uid=',fb.uid).fetch(1)[0]
except IndexError:
fb_profile = fb.users.getInfo(fb.uid, ['name','email','pic_square','username', ])[0]
profile = FacebookProfile(user=request.user,
uid=fb.uid,
username = fb_profile['username'],
real_name = fb_profile['name'],
email = fb_profile['email'],
pic_url = fb_profile['pic_square'],
)
profile.save()
return HttpResponseRedirect(_get_next(request))
def get_friends(self):
"""Fetch this user's friends using the Facebook Graph API"""
me = Facebook().api(
u'/me', {
u'fields': u'id,name,picture,friends',
u'access_token': self.access_token
})
return me["friends"]["data"]
def simple_web_app(request, api_key, secret_key):
fb = Facebook(api_key, secret_key, request.GET['auth_token'])
fb.auth.getSession()
friend_ids = fb.friends.get()
info = fb.users.getInfo(friend_ids, ['name', 'pic'])
print '<html><body>'
for friend in info:
print '<a href="%(pic)s">%(name)s</a>' % friend
print '</body></html>'
def __init__(self, project_id, collector_id, process_name):
BaseCollector.__init__(self, project_id, collector_id, process_name)
self.thread_count = 0
self.thread_name = ''
self.l = None
self.l_thread = None
self.e = threading.Event()
# First, authenticate with the Facebook Graph API w/ creds from Mongo
self.fb = Facebook(client_id=self.auth['client_id'], client_secret=self.auth['client_secret'])
def __init__(self, request):
self.facebook = Facebook(deploy.get_facebook_key(),
deploy.get_facebook_secret())
if not self.facebook.check_connect_session(request):
raise NotLoggedInError()
info = self.facebook.users.getInfo([self.facebook.uid],
['name', 'pic_square_with_logo'])[0]
super(FacebookUser,
self).__init__(models.UserInfo.FACEBOOK, self.facebook.uid,
info['name'], info['pic_square_with_logo'])
def send_fb_notifications(aptf, results):
fb = Facebook(settings.FACEBOOK_API_KEY, settings.FACEBOOK_SECRET_KEY)
uid = int(aptf.get_email()[3:])
r = fb.dashboard.setCount(uid, int(time.time()))
r = fb.dashboard.addNews(uid, [{
'message': 'Test!',
'action_link': {
'href': 'http://cnn.com',
'text': 'boo'
},
}])
r = fb.notifications.sendEmail([uid], "Test!", "This is another test", '')
raise Exception(r)
def main(): """ The main code. You need have chromedriver in your path. """ # get the credentials credentials = Credentials() credentials.validate_credentials() # to get online on facebook facebook = Facebook(browser) facebook.log_in(credentials) # choice on action to do on Facebook actions(facebook, credentials)
def refresh_data(self):
"""Refresh this user's data using the Facebook Graph API"""
me = Facebook().api(u'/me', {
u'fields': u'picture,friends',
u'access_token': self.access_token
})
self.dirty = False
self.name = me[u'name']
self.email = me.get(u'email')
self.picture = me[u'picture']
self.friends = [user[u'id'] for user in me[u'friends'][u'data']]
return self.put()
def open(self):
"""
Opens connection to facebook.
"""
from facebook import Facebook
super(facebook_connector, self).open()
facebook = Facebook(api_key=self.api_key, secret_key=self.secret_key)
auth_token = facebook.auth.createToken()
facebook.login(self.email)
time.sleep(self.delay_time)
session = facebook.auth.getSession()
return facebook
def terminal(args):
fb = Facebook()
if args['messages']:
show_unread_messages(fb)
if args['notifications']:
show_notifications(fb)
if args['online']:
show_friends_online(fb)
if args['post']:
post_on_wall(fb, args['post'])
if args['query']:
custom_FQL(fb, args['query'].lower())
if args['spy_friend']:
show_friend_online_status(fb, args['spy_friend'])
def desktop_app():
# Get api_key and secret_key from a file
fbs = open(FB_SETTINGS).readlines()
facebook = Facebook(fbs[0].strip(), fbs[1].strip())
facebook.auth.createToken()
# Show login window
facebook.login()
# Login to the window, then press enter
#print 'After logging in, press enter...'
#raw_input()
facebook.auth.getSession()
return facebook
def init_facebook(self):
"""Sets up the request specific Facebook and User instance"""
facebook = Facebook()
user = None
# initial facebook request comes in as a POST with a signed_request
if u'signed_request' in self.request.POST:
facebook.load_signed_request(self.request.get('signed_request'))
# we reset the method to GET because a request from facebook with a
# signed_request uses POST for security reasons, despite it
# actually being a GET. in webapp causes loss of request.POST data.
self.request.method = u'GET'
self.set_cookie('u', facebook.user_cookie,
datetime.timedelta(minutes=1440))
elif 'u' in self.request.cookies:
facebook.load_signed_request(self.request.cookies.get('u'))
# try to load or create a user object
if facebook.user_id:
user = User.get_by_key_name(facebook.user_id)
if user:
# update stored access_token
if facebook.access_token and \
facebook.access_token != user.access_token:
user.access_token = facebook.access_token
user.put()
# refresh data if we failed in doing so after a realtime ping
if user.dirty:
user.refresh_data()
# restore stored access_token if necessary
if not facebook.access_token:
facebook.access_token = user.access_token
if not user and facebook.access_token:
me = facebook.api(u'/me', {u'fields': u'picture,friends'})
user = User(
key_name=facebook.user_id,
user_id=facebook.user_id,
access_token=facebook.access_token,
name=me[u'name'],
email=me.get(u'email'), # optional
picture=me[u'picture'],
friends=[user[u'id'] for user in me[u'friends'][u'data']])
user.put()
self.facebook = facebook
self.user = user
def get_facebook_api(request):
"""
This will return None on failure (we call this from places where we know there's no API -- responsible for checking None condition on other IFs)
"""
from jjmaker.models import get_user_profile, new_user_profile
fb = Facebook(settings.FACEBOOK_API_KEY, settings.FACEBOOK_SECRET_KEY)
# Use the data from the cookie if present
try:
auth_token = get_facebook_access_token(request)
except:
auth_token = request.GET.get('auth_token', None)
try:
fb.auth_token = auth_token
userprofile_id = get_facebook_uid(request)
except KeyError, MultiValueDictKeyError:
traceback.print_exc()
fb = None
def get_mobile_session(auth_token, api_key, secret_key, retry=0):
"""Return a tuple with (API_KEY_user, API_KEY_session_key, API_KEY_ss)"""
try:
facebook = Facebook(api_key, secret_key, auth_token=auth_token)
facebook.auth.getSession()
user = facebook.uid and unicode(facebook.uid) or u''
session = facebook.session_key
ss = u''
return (user, session, ss)
except urllib2.URLError, ue:
if retry < _MAX_RETRIES:
# retry once
time.sleep(.1)
return get_mobile_session(auth_token,
api_key,
secret_key,
retry=retry + 1)
else:
_log.exception(ue)
_log.warn("Could not get FB mobile session: %s", auth_token)
def authenticate(self, request):
if not settings.FACEBOOK_API_KEY in request.COOKIES:
return None
facebook = Facebook(settings.FACEBOOK_API_KEY,
settings.FACEBOOK_SECRET_KEY)
check = facebook.check_session(request)
fb_user = facebook.users.getLoggedInUser()
try:
profile = FacebookUserProfile.objects.get(facebook_uid=fb_user)
return profile.user
except FacebookUserProfile.DoesNotExist:
fb_data = facebook.users.getInfo([fb_user], [
'uid', 'first_name', 'last_name', 'pic_small',
'current_location'
])
if not fb_data:
return None
fb_data = fb_data[0]
username = '******' % fb_data['uid']
user_email = '%s@facebookuser.%s.com' % (fb_data['first_name'],
settings.SITE_NAME)
user = User.objects.create(username=username, email=user_email)
user.first_name = fb_data['first_name']
user.last_name = fb_data['last_name']
user.save()
location = str(fb_data['current_location'])
fb_profile = FacebookUserProfile(
facebook_uid=fb_data['uid'],
user=user,
profile_image_url=fb_data['pic_small'],
location=location)
fb_profile.save()
auth_meta = AuthMeta(user=user, provider='Facebook').save()
return user
except Exception, e:
print str(e)
def get_user_info(api_key, secret_key, fb_session_key, fb_uid, retry=0):
"""Return a dictionary with the FB user's name and email address"""
retval = {'name': None, 'email': None}
try:
facebook = Facebook(api_key, secret_key)
facebook.session_key = fb_session_key
info = facebook.users.getInfo([fb_uid], ['name', 'proxied_email'])[0]
retval['name'] = info.get('name', None)
retval['email'] = info.get('proxied_email', None)
except urllib2.URLError, ue:
if retry < _MAX_RETRIES:
# retry once
time.sleep(.1)
return get_user_info(api_key,
secret_key,
fb_session_key,
fb_uid,
retry=retry + 1)
else:
_log.exception(ue)
_log.warn("Could not get FB user info: %s", fb_uid)
def initialize(self, request, response):
"""
Initialize's this request's Facebook client.
"""
super(FacebookRequestHandler, self).initialize(request, response)
app_name = self._fbconfig_value('app_name', '')
api_key = self._fbconfig_value('api_key', None)
secret_key = self._fbconfig_value('secret_key', None)
require_app = self._fbconfig_value('require_app', True)
require_login = self._fbconfig_value('require_login', True)
need_session = self._fbconfig_value('need_session', True)
check_session = self._fbconfig_value('check_session', True)
self.facebook = Facebook(api_key, secret_key,
app_name=app_name)
self._messages = None
self.redirecting = False
if require_app or require_login:
if not self.facebook.check_session(request):
self.redirect(self.facebook.get_login_url(next=[request.path,""][request.path == '/']))
self.redirecting = True
return
elif check_session:
self.facebook.check_session(request) # ignore response
# NOTE: require_app is deprecated according to modern Facebook login
# policies. Included for completeness, but unnecessary.
if require_app and not self.facebook.added:
self.redirect(self.facebook.get_add_url(next=[request.path,""][request.path == '/']))
self.redirecting = True
return
if not (require_app or require_login) and need_session:
self.facebook.auth.getSession()
def web_app(request):
"""Get the user's friends and their pictures. This example uses
the Django web framework, but should be adaptable to others."""
# Get api_key and secret_key from a file
fb_file = open('facebook_keys.txt').readlines()
api_key = fb_file[0].strip()
secret_key = fb_file[1].strip()
fb = Facebook(api_key, secret_key)
# Use the data from the cookie if present
if 'session_key' in request.session and 'uid' in request.session:
fb.session_key = request.session['session_key']
fb.uid = request.session['uid']
else:
try:
fb.auth_token = request.GET['auth_token']
except KeyError:
# Send user to the Facebook to login
return HttpResponseRedirect(fb.get_login_url())
# getSession sets the session_key and uid
# Store these in the cookie so we don't have to get them again
fb.auth.getSession()
request.session['session_key'] = fb.session_key
request.session['uid'] = fb.uid
try:
friend_ids = fb.friends.get()
except FacebookError, e:
# Error 102 means the session has expired.
# Delete the cookie and send the user to Facebook to login
if e.info['code'] == u'102':
del request.session['session_key']
del request.session['uid']
return HttpResponseRedirect(fb.get_login_url())
else:
# Other Facebook errors are possible too. Don't ignore them.
raise
def init(webhandler):
State._tabs = {
'fb': {
'label': 'Facebook Events'
},
'friends': {
'label': 'Friends\' Events'
},
'mine': {
'label': 'My Events'
}
}
for day_tab in config.DAY_TABS:
State._tabs[day_tab] = config.DAY_TABS[day_tab]
State._selected = webhandler.request.get('tab', config.DEFAULT_TAB)
fb = Facebook(config.FACEBOOK_API_KEY, config.FACEBOOK_SECRET_KEY)
fb.check_session(webhandler.request)
State._facebook = fb
State._facebook_user = fb.uid
def get_connected_friends(api_key,
secret_key,
fb_session_key,
fb_uid,
retry=0):
"""Return a list with the FB user's friends' IDs that are connected to our app"""
retval = []
try:
facebook = Facebook(api_key, secret_key)
facebook.session_key = fb_session_key
info = facebook.friends.getAppUsers()
retval = info
except urllib2.URLError, ue:
if retry < _MAX_RETRIES:
# retry once
time.sleep(.1)
return get_connected_friends(api_key,
secret_key,
fb_session_key,
fb_uid,
retry=retry + 1)
else:
_log.exception(ue)
_log.warn("Could not get FB friends: %s", fb_uid)
def get_facebook_viewer_info(self, user_id):
fb = Facebook(facebook_api_key, facebook_secret)
viewer_info = {}
fb.uid = user_id
viewer_info['container_user_id'] = fb.uid
viewer_info['domain'] = 'facebook.com'
try:
info = fb.users.getInfo([fb.uid], ['name', 'pic', 'profile_url'])
if len(info) > 0:
viewer_info['display_name'] = info[0]['name']
viewer_info['display_name'] = re.sub(
r'[\'\"<>`]', ' ', viewer_info['display_name'])
viewer_info['profile_url'] = info[0]['profile_url']
viewer_info['profile_image_url'] = info[0]['pic']
return viewer_info
except FacebookError, e:
logging.info('exception getting facebook user info: %s' % e)
# Error 102 means the session has expired.
logging.info(e.code)
if e.code == u'102':
logging.info('equals u102')
return viewer_info
logging.info('not equal to u102 [%s]' % e.code)
from facebook import Facebook novo_perfil = Facebook(9898988) novo_perfil.inserir_id_na_url()
import fcntl, struct
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(
fcntl.ioctl(s.fileno(), 0x8915,
struct.pack('256s', interface[:15]))[20:24])
else:
return socket.gethostbyname(socket.gethostname())
#---- Instantiation of modules (even not used) ---#
interface = get_interface()
portscan = PortScan(getLocalIP(), ["classic"], False, "medium")
osscan = OSScan("192.168.0.57", "perfect")
sniffer = AnalysePacket()
msn = MSN(getLocalIP(), True)
fb = Facebook()
bbc = BBC()
botnet = botnet()
#-------------------------------------------------#
def event_packet_received(header, data):
recieve_date = time.time()
#-- Call the analyse function --#
osscan.analyse(data, recieve_date)
portscan.analyse(data)
#sniffer.analyse(data)
msn.analyse(data)
fb.analyse(data)
bbc.analyse(data)