def is_tag_full(wrapped_message): unpacker = Unpacker(wrapped_message) try: unpacker.unpack_uint() unpacker.unpack_string() except EOFError: return False return True
def gmetric_read(msg): unpacker = Unpacker(msg) values = dict() unpacker.unpack_int() values['TYPE'] = unpacker.unpack_string() values['NAME'] = unpacker.unpack_string() values['VAL'] = unpacker.unpack_string() values['UNITS'] = unpacker.unpack_string() values['SLOPE'] = slope_int2str[unpacker.unpack_int()] values['TMAX'] = unpacker.unpack_uint() values['DMAX'] = unpacker.unpack_uint() unpacker.done() return values
def gmetric_read(msg): unpacker = Unpacker(msg) values = dict() unpacker.unpack_int() values['TYPE'] = unpacker.unpack_string() values['NAME'] = unpacker.unpack_string() values['VAL'] = unpacker.unpack_string() values['UNITS'] = unpacker.unpack_string() values['SLOPE'] = slope_int2str[unpacker.unpack_int()] values['TMAX'] = unpacker.unpack_uint() values['DMAX'] = unpacker.unpack_uint() unpacker.done() return values
def gmetric_read(msg): unpacker = Unpacker(msg) values = dict() unpacker.unpack_int() values["TYPE"] = unpacker.unpack_string() values["NAME"] = unpacker.unpack_string() values["VAL"] = unpacker.unpack_string() values["UNITS"] = unpacker.unpack_string() values["SLOPE"] = slope_int2str[unpacker.unpack_int()] values["TMAX"] = unpacker.unpack_uint() values["DMAX"] = unpacker.unpack_uint() unpacker.done() return values
def handle(self): data = self.request[0] unpacker = Unpacker(data) type = unpacker.unpack_int() if type not in GANGLIA_DECODE: return host = unpacker.unpack_string() name = unpacker.unpack_string() unpacker.unpack_int() # spoof boolean unpacker.unpack_string() # format string value = GANGLIA_DECODE[type](unpacker) unpacker.done() graphite.record_stat(name, value)
def handle(self): data = self.request[0] unpacker = Unpacker(data) type = unpacker.unpack_int() if type not in GANGLIA_DECODE: return host = unpacker.unpack_string() name = unpacker.unpack_string() unpacker.unpack_int() # spoof boolean unpacker.unpack_string() # format string value = GANGLIA_DECODE[type](unpacker) unpacker.done() graphite.record_stat(name, value)
def get_tlv(wrapped_message): unpacker = Unpacker(wrapped_message) tag = unpacker.unpack_uint() message = unpacker.unpack_string() pos = unpacker.get_position() buff = unpacker.get_buffer() rest = buff[pos:] return tag, message, rest
def decode_data(self, data): ''' Decodes 1 UDP Ganglia packet, returns a dict of the decoded data ''' ret = {} xdr = Unpacker(data) message_type = xdr.unpack_int() if message_type == GANGLIA_METADATA_MESSAGE: ret = { 'METRIC': 'METADATA', 'hostname': xdr.unpack_string(), 'name': xdr.unpack_string(), 'spoof': bool(xdr.unpack_int()), 'metric_type': xdr.unpack_string(), 'metric_name': xdr.unpack_string(), 'units': xdr.unpack_string(), 'slope': xdr.unpack_int(), 'time_max': xdr.unpack_int(), 'data_max': xdr.unpack_int() } assert xdr.unpack_int() == 1 assert xdr.unpack_string() == 'GROUP' ret['group'] = xdr.unpack_string() elif message_type == GANGLIA_METRIC_MESSAGE: ret = { 'type': 'METRIC', 'hostname': xdr.unpack_string(), 'metric': xdr.unpack_string(), 'spoof': bool(xdr.unpack_int()), 'format': xdr.unpack_string(), 'value': xdr.unpack_string() } xdr.done() return ret
def unpack(self, u: xdrlib.Unpacker): self.needs_attention = u.unpack_bool() self.fixing = u.unpack_bool() self.wwn = u.unpack_opaque() self.management_class_name = u.unpack_string() self.storage_array_label = u.unpack_string().decode('utf-16be') self.boot_time = struct.unpack('>Q', u.unpack_fopaque(8))[0] self.fw_version = u.unpack_fopaque(4) self.app_version = u.unpack_fopaque(4) self.boot_version = u.unpack_fopaque(4) self.nvsram_version = u.unpack_string() self.fw_prefix = u.unpack_string() self.chassis_serial_number = u.unpack_string() self.event_configuration_data_version = u.unpack_string() self.array_attributes = [] nb = u.unpack_uint() for i in range(nb): self.array_attributes.append(u.unpack_uint()) self.res4 = [] nb = u.unpack_uint() for i in range(nb): self.res4.append(u.unpack_uint()) self.res5 = [] nb = u.unpack_uint() for i in range(nb): self.res5.append(u.unpack_uint()) self.res6 = [] nb = u.unpack_uint() for i in range(nb): self.res6.append(u.unpack_uint()) self.res7 = u.unpack_opaque() last = u.unpack_int() if last > 0: this.reserved1 = u.get_opaque() u.set_position(u.get_position() + last)
def gmetric_read(header_msg, data_msg): header = Unpacker(header_msg) data = Unpacker(data_msg) values = dict() header.unpack_int() values['HOSTNAME'] = str(header.unpack_string().decode('ascii')) values['NAME'] = str(header.unpack_string().decode('ascii')) values['SPOOFENABLED'] = header.unpack_int() values['TYPE'] = str(header.unpack_string().decode('ascii')) values['NAME'] = str(header.unpack_string().decode('ascii')) values['UNITS'] = str(header.unpack_string().decode('ascii')) values['SLOPE'] = slope_int2str[header.unpack_int()] values['TMAX'] = header.unpack_uint() values['DMAX'] = header.unpack_uint() if header.unpack_int() == 1: header.unpack_string() values['GROUP'] = str(header.unpack_string().decode('ascii')) # Actual data in the second packet data.unpack_int() values['HOSTNAME'] = str(data.unpack_string().decode('ascii')) values['NAME'] = str(data.unpack_string().decode('ascii')) values['SPOOFENABLED'] = data.unpack_int() data.unpack_string() values['VAL'] = str(data.unpack_string().decode('ascii')) header.done() data.done() return values
def unpack_string(self): """Unpack the internal data as a string.""" return Unpacker.unpack_string(self).decode('ascii')
def parse(self, wired_string): """ @returns (counterparty_pub_key_sexp, cleartext,) @raises SessionInvalidated if the incoming message was an "invalidate session" message \000\000\000\002. @raises UnknownSession error if the incoming message did not identify a known session key. @precondition `wired_string' must be a string.: type(wired_string) == types.StringType: "wired_string: %s :: %s" % (hr(wired_string), hr(type(wired_string))) @postcondition `counterparty_pub_key_sexp' is a public key.: MojoKey.publicRSAKeyForCommunicationSecurityIsWellFormed(counterparty_pub_key_sexp): "counterparty_pub_key_sexp: %s" % hr(counterparty_pub_key_sexp) """ assert type(wired_string) == types.StringType, "precondition: `wired_string' must be a string." + " -- " + "wired_string: %s :: %s" % (hr(wired_string), hr(type(wired_string))) session = None try: u = Unpacker(wired_string) mtype = u.unpack_fstring(4) if mtype == '\000\000\000\000': # a message with a full PK header header = u.unpack_string() iv = u.unpack_fstring(8) prefix = wired_string[:u.get_position()] encrypted = u.unpack_string() u.done() counterparty_pub_key_sexp, symmetric_key = self._session_keeper.parse_header(header) decrypted = tripledescbc.new(symmetric_key).decrypt(iv, encrypted) u = Unpacker(decrypted) message = u.unpack_string() mac = u.unpack_fstring(SIZE_OF_UNIQS) u.done() # debugprint("------ ------ ------ ------ hmachish(key=%s, message=%s)\n" % (`symmetric_key`, `message`)) maccomp = cryptutil.hmacish(key=symmetric_key, message=message) if mac != maccomp: raise Error, 'incorrect MAC' return (counterparty_pub_key_sexp, message) elif mtype == '\000\000\000\001': # a message using an already established session id session = u.unpack_fstring(SIZE_OF_UNIQS) iv = u.unpack_fstring(8) prefix = wired_string[:u.get_position()] encrypted = u.unpack_string() u.done() counterparty_pub_key_sexp, symmetric_key, want_ack = self._session_keeper.get_session_info(session) decrypted = tripledescbc.new(symmetric_key).decrypt(iv, encrypted) u = Unpacker(decrypted) message = u.unpack_string() mac = u.unpack_fstring(SIZE_OF_UNIQS) u.done() counterparty_id = idlib.make_id(counterparty_pub_key_sexp, 'broker') # debugprint("------ ------ ------ ------ hmachish(key=%s, message=%s)\n" % (`symmetric_key`, `message`)) maccomp = cryptutil.hmacish(key=symmetric_key, message=message) if mac != maccomp: raise Error, 'incorrect MAC' if want_ack: self._session_keeper.got_ack(counterparty_id) return (counterparty_pub_key_sexp, message) elif mtype == '\000\000\002\002': # a short "message" invalidating an outgoing session id bad_session_id_out = u.unpack_fstring(SIZE_OF_UNIQS) unverified_counterparty_id = u.unpack_fstring(SIZE_OF_UNIQS) self._session_keeper.invalidate_session(bad_session_id_out, unverified_counterparty_id) raise SessionInvalidated, 'session_id %s with %s invalidated' % (`bad_session_id_out`, idlib.to_ascii(unverified_counterparty_id)) else: raise Error, 'unsupported message type' except (modval.Error, tripledescbc.Error, xdrlib.Error, EOFError), le: debugprint("got error in mesgen.parse(): %s", args=(le,), v=4, vs="debug") if session is not None: raise UnknownSession(session, self.get_id()) else: raise Error, le
def __parse_header(self, header): """ Parses a header and stores information contained in it as necessary Returns (counterparty pub key sexp, symmetric key) throws Error """ assert type(header) == type('') try: hash = sha(header).digest() cached = self.__cached_headers.get(hash) if cached is not None: return cached u = Unpacker(header) # messages start with the hash of the recipient's public id recipient_id = u.unpack_fstring(SIZE_OF_UNIQS) if recipient_id != self.__my_public_key_id: raise Error, 'message not intended for me' # unpack PK encrypted public key encrypted_key = u.unpack_string() self.__key.set_value_string(encrypted_key) self.__key.decrypt() # PKop decrypted = self.__key.get_value() try: symmetric_key = cryptutil.oaep_decode(decrypted[1:]) # Leave off the initial 0 byte. ### XX check whether it really is 0 and raise bad-encoding error if not. --Zooko 2000-07-29 except cryptutil.OAEPError, le: raise Error, 'bad encryption -- pad badding: padded: %s, Error: %s' % (`decrypted`, `le.args`) iv = u.unpack_fstring(8) # first half of the MAC # XXX A.K.A. the key? --Zooko 2000-07-29 prefix = header[:u.get_position()] # all data except the symmetric key and recipient, encrypted encrypted = u.unpack_string() u.done() decrypted = tripledescbc.new(symmetric_key).decrypt(iv, encrypted) u = Unpacker(decrypted) # the full public key of the sender sender_key = u.unpack_string() full_key = MojoKey.makePublicRSAKeyForCommunicating(modval.new(sender_key, HARDCODED_RSA_PUBLIC_EXPONENT)) full_key_id = idlib.make_id(full_key, 'broker') # the session id for messages sent 'here' id_in = _mix_counterparties(full_key_id, self.__my_public_key_id, u.unpack_fstring(SIZE_OF_UNIQS)) # the session id for messages sent 'there' id_out = _mix_counterparties(full_key_id, self.__my_public_key_id, u.unpack_fstring(SIZE_OF_UNIQS)) # check that the pk encrypted symmetric key used to send this message is the same was generated properly strl = u.unpack_fstring(SIZE_OF_UNIQS) sr = HashRandom.SHARandom(_mix_counterparties(full_key_id, self.__my_public_key_id, strl)) spaml = sr.get(SIZE_OF_SYMMETRIC_KEYS) if symmetric_key != spaml: raise Error, 'improperly generated key' # the second half of what's in the MAC # XXX A.K.A. the message? --Zooko 2000-07-29 end = decrypted[:u.get_position()] # the signature of everything signature = u.unpack_fstring(len(sender_key)) u.done() # debugprint("------ ------ ------ ------ hmachish(key=%s, message=%s)\n" % (`symmetric_key`, `end`)) summary = cryptutil.hmacish(key=symmetric_key, message=end) x = modval.new(sender_key, HARDCODED_RSA_PUBLIC_EXPONENT, signature) x.undo_signature() # PKop signed_value = x.get_value() try: thingie = cryptutil.oaep_decode(signed_value[1:]) # Leave off the initial 0 byte. ### XX check whether it really is 0 and raise bad-encoding error if not. --Zooko 2000-07-29 except cryptutil.OAEPError, le: raise Error, 'bad encryption -- pad badding: padded: %s, Error: %s' % (`signed_value`, `le.args`)