def new_secure_hash(text_type=None): """ Returns either a sha1 hash object (if called with no arguments), or a hexdigest of the sha1 hash of the argument `text_type`. """ if text_type: return sha1(text_type).hexdigest() else: return sha1()
def getMusicBrainzDiscId(self): """ Calculate the MusicBrainz disc ID. @rtype: str @returns: the 28-character base64-encoded disc ID """ if self.mbdiscid: self.log('getMusicBrainzDiscId: returning cached %r' % self.mbdiscid) return self.mbdiscid values = self._getMusicBrainzValues() # MusicBrainz disc id does not take into account data tracks # P2.3 try: import hashlib sha1 = hashlib.sha1 except ImportError: from sha import sha as sha1 import base64 sha = sha1() # number of first track sha.update("%02X" % values[0]) # number of last track sha.update("%02X" % values[1]) sha.update("%08X" % values[2]) # offsets of tracks for i in range(1, 100): try: offset = values[2 + i] except IndexError: #print 'track', i - 1, '0 offset' offset = 0 sha.update("%08X" % offset) digest = sha.digest() assert len(digest) == 20, \ "digest should be 20 chars, not %d" % len(digest) # The RFC822 spec uses +, /, and = characters, all of which are special # HTTP/URL characters. To avoid the problems with dealing with that, I # (Rob) used ., _, and - # base64 altchars specify replacements for + and / result = base64.b64encode(digest, '._') # now replace = result = "-".join(result.split("=")) assert len(result) == 28, \ "Result should be 28 characters, not %d" % len(result) self.log('getMusicBrainzDiscId: returning %r' % result) self.mbdiscid = result return result
def do_SSH_dhkex(self, payload): e = self.read_SSH_mpint(payload) #print(payload.getbuffer()) #print(self.make_SSH_mpint(e)) y = secrets.randbits(512) f = pow(dh.g, y, dh.p) K = pow(e, y, dh.p) self.shared_secret = K #print("Shared secret: {}".format(hex(K))) prehash = self.make_SSH_string(self.client_id_str) prehash += self.make_SSH_string(self.ID_STR) prehash += self.make_SSH_string(self.client_kexinit) prehash += self.make_SSH_string(self.server_kexinit) prehash += self.make_SSH_pubkeystr() prehash += self.make_SSH_mpint(e) prehash += self.make_SSH_mpint(f) prehash += self.make_SSH_mpint(K) print(prehash) H = sha.sha1(prehash) #print(H) packet = struct.pack("B", self.SSH_MSG_KEXDH_REPLY) packet += self.make_SSH_pubkeystr() packet += self.make_SSH_mpint(f) packet += self.make_SSH_rsasig(H) self.write_SSH_packet(packet) self.write_SSH_packet(struct.pack("B", self.SSH_MSG_NEWKEYS))
def getMusicBrainzDiscId(self): """ Calculate the MusicBrainz disc ID. @rtype: str @returns: the 28-character base64-encoded disc ID """ if self.mbdiscid: logger.debug('getMusicBrainzDiscId: returning cached %r' % self.mbdiscid) return self.mbdiscid values = self._getMusicBrainzValues() # MusicBrainz disc id does not take into account data tracks # P2.3 try: import hashlib sha1 = hashlib.sha1 except ImportError: from sha import sha as sha1 import base64 sha = sha1() # number of first track sha.update("%02X" % values[0]) # number of last track sha.update("%02X" % values[1]) sha.update("%08X" % values[2]) # offsets of tracks for i in range(1, 100): try: offset = values[2 + i] except IndexError: #print 'track', i - 1, '0 offset' offset = 0 sha.update("%08X" % offset) digest = sha.digest() assert len(digest) == 20, \ "digest should be 20 chars, not %d" % len(digest) # The RFC822 spec uses +, /, and = characters, all of which are special # HTTP/URL characters. To avoid the problems with dealing with that, I # (Rob) used ., _, and - # base64 altchars specify replacements for + and / result = base64.b64encode(digest, '._') # now replace = result = "-".join(result.split("=")) assert len(result) == 28, \ "Result should be 28 characters, not %d" % len(result) logger.debug('getMusicBrainzDiscId: returning %r' % result) self.mbdiscid = result return result
def TraktCall(method, api, username=None, password=None, data={}): """ A generic method for communicating with trakt. Uses the method and data provided along with the auth info to send the command. method: The URL to use at trakt, relative, no leading slash. api: The API string to provide to trakt username: The username to use when logging in password: The unencrypted password to use when logging in Returns: A boolean representing success """ #logger.log("trakt: Call method " + method, logger.DEBUG) # if the API isn't given then it failed if not api: return None # replace the API string with what we found method = method.replace("%API%", api) # make the full url url = 'https://api.trakt.tv/' + method # take the URL params and make a json object out of them encoded_data = json.JSONEncoder().encode(data) request = Request(url, encoded_data) # if the username isn't given then it failed if username and password: pwdsha1 = sha1(password).hexdigest() base64string = base64.encodestring( '%s:%s' % (username, pwdsha1)).replace('\n', '') request.add_header("Accept", "*/*") request.add_header("User-Agent", "CPython/2.7.5 Unknown/Unknown") request.add_header("Authorization", "Basic %s" % base64string) # request the URL from trakt and parse the result as json try: #logger.log("trakt: Calling method http://api.trakt.tv/" + method + ", with data" + encoded_data, logger.DEBUG) stream = urlopen(request).read() # check if results are valid if stream == '[]': resp = 'NULL' else: resp = json.JSONDecoder().decode(stream) if ("error" in resp): raise Exception(resp["error"]) except (IOError): #logger.log("trakt: Failed calling method", logger.ERROR) return None #logger.log("trakt: Failed calling method", logger.ERROR) return resp
def TraktCall(method, api, username=None, password=None, data={}): """ A generic method for communicating with trakt. Uses the method and data provided along with the auth info to send the command. method: The URL to use at trakt, relative, no leading slash. api: The API string to provide to trakt username: The username to use when logging in password: The unencrypted password to use when logging in Returns: A boolean representing success """ # logger.log("trakt: Call method " + method, logger.DEBUG) # if the API isn't given then it failed if not api: return None # replace the API string with what we found method = method.replace("%API%", api) # make the full url url = "https://api.trakt.tv/" + method # take the URL params and make a json object out of them encoded_data = json.JSONEncoder().encode(data) request = Request(url, encoded_data) # if the username isn't given then it failed if username and password: pwdsha1 = sha1(password).hexdigest() base64string = base64.encodestring("%s:%s" % (username, pwdsha1)).replace("\n", "") request.add_header("Accept", "*/*") request.add_header("User-Agent", "CPython/2.7.5 Unknown/Unknown") request.add_header("Authorization", "Basic %s" % base64string) # request the URL from trakt and parse the result as json try: # logger.log("trakt: Calling method http://api.trakt.tv/" + method + ", with data" + encoded_data, logger.DEBUG) stream = urlopen(request).read() # check if results are valid if stream == "[]": resp = "NULL" else: resp = json.JSONDecoder().decode(stream) if "error" in resp: raise Exception(resp["error"]) except (IOError): # logger.log("trakt: Failed calling method", logger.ERROR) return None # logger.log("trakt: Failed calling method", logger.ERROR) return resp
def create_handshake(handshake): handshakelines = handshake.split("\r\n") matching = [s for s in handshakelines if "Sec-WebSocket-Key: " in s] returning_handshake = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " if(len(matching) > 0): returning_handshake+=base64.b64encode(sha.sha1((matching[0][19:]+"258EAFA5-E914-47DA-95CA-C5AB0DC85B11").encode(), False)).decode() returning_handshake+="\r\n\r\n" return returning_handshake
def _session_id(): id_str = "%f%s%f%s" % ( time.time(), id({}), random.random(), getpid() ) # NB: nothing against second parameter to b64encode, but it seems # to be slower than simple chained replacement raw_id = b64encode(sha1(id_str).digest()) return raw_id.replace('+', '-').replace('/', '_').rstrip('=')
def create_handshake(handshake): handshakelines = handshake.split("\r\n") matching = [s for s in handshakelines if "Sec-WebSocket-Key: " in s] returning_handshake = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " if (len(matching) > 0): returning_handshake += base64.b64encode( sha.sha1((matching[0][19:] + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").encode(), False)).decode() returning_handshake += "\r\n\r\n" return returning_handshake
def sign(m, d, n): OIDSTR = b"\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14" h = sha.sha1(m) padded = b"\x00\x01" + b"\xFF" * (256 - 23 - len(OIDSTR)) + b"\x00" + OIDSTR + h c = 0 for x in padded: c <<= 8 c |= x sig = pow(c, d, n) output = b"" for _ in range(2048 // 8): output = struct.pack("B", sig & 0xFF) + output sig >>= 8 return output
def make_hash_authorization_signature(method, url, date_string, company_id, user_id, nonce, api_key): s = ("%(method)s %(path)s\r\n" "Date: %(date_string)s\r\n" "X-SuT-CID: %(company_id)s\r\n" "X-SuT-UID: %(user_id)s\r\n" "X-SuT-Nonce: %(nonce)s\r\n" "%(api_key)s" % dict(method=method, path=urllib_parse.urlparse(url).path.rstrip('/'), date_string=date_string, company_id=company_id, user_id=user_id, nonce=nonce, api_key=api_key)) return sha1(s.encode('utf-8')).hexdigest()
def secret_to_key(secret, s2k_specifier): """Used to generate a hashed password string. DOCDOC.""" c = ord(s2k_specifier[8]) EXPBIAS = 6 count = (16 + (c & 15)) << ((c >> 4) + EXPBIAS) d = sha1() tmp = s2k_specifier[:8] + secret slen = len(tmp) while count: if count > slen: d.update(tmp) count -= slen else: d.update(tmp[:count]) count = 0 return d.digest()
def secret_to_key(secret, s2k_specifier): """Used to generate a hashed password string. DOCDOC.""" c = ord(s2k_specifier[8]) EXPBIAS = 6 count = (16+(c&15)) << ((c>>4) + EXPBIAS) d = sha1() tmp = s2k_specifier[:8]+secret slen = len(tmp) while count: if count > slen: d.update(tmp) count -= slen else: d.update(tmp[:count]) count = 0 return d.digest()
def hashAndBase64(s): return stringToBase64(sha1(s).digest())
def hashFunction(self, number): """ Fonction de hashage d'un entier, renvoie un autre entier issue du hashage""" hexe = number.to_bytes(self.bit_size//8, sys.byteorder) #return int.from_bytes(Hasher().digest(hexe), sys.byteorder) return int.from_bytes(str.encode(sha.sha1(str(hexe))), sys.byteorder)
import socket # Import socket module import sha s = socket.socket() # Create a socket object host = socket.gethostname() # Get local machine name port = 12345 # Reserve a port for your service. s.bind((host, port)) # Bind to the port s.listen(1) # Now wait for client connection. while True: c, addr = s.accept() # Establish connection with client. print 'Got connection from ', addr data = raw_input("enter the data to be sent ") c.send(data) sh = sha.sha1(data) sh.process_data() msgD = sh.sha_1() print msgD c.send(msgD) data = "" c.close() # Close the connection
def __decorate(func): rkey = sha1(str(time())).hexdigest()[:7] rkw = 'kw_%s' % rkey code = func.func_code varnames = list(code.co_varnames) defaults = func.func_defaults or () func_name = func.func_name varargs = varkwargs = None if code.co_flags & CO_VARKEYWORDS: varkwargs = varnames.pop(-1) if code.co_flags & CO_VARARGS: varargs = varnames.pop(-1) params = [varnames.pop(0)]; add = params.append params2 = params[:]; add2 = params2.append default_pointer = len(varnames) - len(defaults) for idx, varname in enumerate(varnames): if idx < default_pointer: add(varname) add2("%s[%r]" % (rkw, varname)) else: add("%s=defaults_%s[%s]" % (varname, rkey, idx-default_pointer)) add2("%s=%s.get(%r, defaults_%s[%s])" % (varname, rkw, varname, rkey, idx-default_pointer)) if varargs: add("*%s" % varargs) add2("*%s[%r]" % (rkw, varargs)) if varkwargs: add("**%s" % varkwargs) add2("**%s[%r]" % (rkw, varkwargs)) params = ", ".join(params) params2 = ", ".join(params2) source = """ def %(func_name)s(%(params)s): kws_%(r)s = locals() kw_%(r)s = {} for key_%(r)s in kws_%(r)s: if key_%(r)s in spec_%(r)s: try: kw_%(r)s[key_%(r)s] = spec_%(r)s[key_%(r)s](kws_%(r)s[key_%(r)s]) except Exception: raise ValueError( "Could not validate input argument '%%s=%%s'" %% (key_%(r)s, kws_%(r)s[key_%(r)s]) ) else: kw_%(r)s[key_%(r)s] = kws_%(r)s[key_%(r)s] return func_%(r)s(%(params2)s) """ % dict(params=params, params2=params2, r=rkey, func_name=func_name) env = { 'func_%s' % rkey: func, 'spec_%s' % rkey: spec, 'defaults_%s' % rkey: defaults, 'ValueError': ValueError } exec source in env return env[func_name]
import socket # Import socket module import sha s = socket.socket() # Create a socket object host = socket.gethostname() # Get local machine name port = 12345 # Reserve a port for your service. s.connect((host, port)) message = s.recv(1024) print str(message) msgD = s.recv(1024) print str(msgD) sh = sha.sha1(message) sh.process_data() msgD1 = sh.sha_1() print msgD1 if msgD == msgD1: print "message is integrate." elif msgD != msgD1: print "message not integrate" s.close
def sha_calculator(string): """Function to calculate sha1sum""" ans1 = sha1(string) return (ans1)
def __init__(self): self.MAGIC = sha1('[TL]').digest() self.KEY = sha1('TL-Cookies').digest()