def fill(self, d): """ """ self._d = d idx = 0 self.version, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.alg, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.s2k, idx = S2K.strcalc_s2k(d[idx:], idx)
def fill(self, d): self._d = d idx = 0 __version_d = d[idx:idx+1] self.version, idx = STN.strcalc(STN.str2int, __version_d, idx) if self.version in [2, 3, 4]: __created_d = d[idx:idx+4] self.created, idx = STN.strcalc(STN.str2int, __created_d, idx) if self.version in [2, 3]: self.__expires_d = d[idx:idx+2] self.expires, idx = STN.strcalc(STN.str2int, self.__expires_d, idx) __alg_d = d[idx:idx+1] self.alg, idx = STN.strcalc(STN.str2int, __alg_d, idx) # resolve MPIs if self.alg in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]: self.RSA_n, idx = MPI.strcalc_mpi(d[idx:], idx) self.RSA_e, idx = MPI.strcalc_mpi(d[idx:], idx) self._mpi_d = self.RSA_n._d + self.RSA_e._d elif ASYM_DSA == self.alg: self.DSA_p, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_q, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_g, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_y, idx = MPI.strcalc_mpi(d[idx:], idx) self._mpi_d = self.DSA_p._d + self.DSA_q._d + self.DSA_g._d + self.DSA_y._d elif self.alg in [ASYM_ELGAMAL_E, ASYM_ELGAMAL_EOS]: self.ELGAMAL_p, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_g, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_y, idx = MPI.strcalc_mpi(d[idx:], idx) self._mpi_d = self.ELGAMAL_p._d + self.ELGAMAL_g._d + self.ELGAMAL_y._d else: raise NotImplementedError("Unsupported key algorithm. Received alg->(%s)" % self.alg) # set fingerprint if self.version in [2, 3]: integer_data = self.RSA_n._int_d + self.RSA_e._int_d self.fingerprint = md5.new(integer_data).hexdigest().upper() # see fingerprint/id notes in doc/NOTES.txt self.id = STN.str2hex(self.RSA_n._int_d[-8:]) elif 4 == self.version: f = ['\x99'] f_data = ''.join([__version_d, __created_d, __alg_d, self._mpi_d]) length = len(f_data) hi = (chr((0xffff & length) >> 8)) # high order packet length lo = (chr(0xff & length)) # low order packet length f.append(hi + lo) f.append(f_data) self.fingerprint = sha.new(''.join(f)).hexdigest().upper() # see fingerprint/id notes in doc/NOTES.txt self.id = self.fingerprint[-16:] else: # unsupported packet version raise NotImplementedError("Unsupported key version: %s" % self.version) return idx
def fill(self, d): self._d = d self.format = d[0:1] self.fnlen = STN.str2int(d[1:2]) idx = 2 if 0 < self.fnlen: self.filename, idx = STN.strcalc(None, d[idx:idx+self.fnlen], idx) else: self.filename = None self.modified, idx = STN.strcalc(STN.str2int, d[idx:idx+4], idx) self.data = d[idx:]
def fill(self, d): self._d = d idx = 0 self.version, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx + 8], idx) self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) if self.alg_pubkey in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]: self.RSA_me_modn, idx = MPI.strcalc_mpi(d[idx:], idx) elif ASYM_ELGAMAL_E == self.alg_pubkey: self.ELGAMAL_gk_modp, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_myk_modp, idx = MPI.strcalc_mpi(d[idx:], idx) else: raise PGPValueError, "Unsupported public key algorithm. Received alg_pubkey->(%s)" % self.alg_pubkey
def fill(self, d): self._d = d idx = 0 self.version, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx+8], idx) self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) if self.alg_pubkey in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]: self.RSA_me_modn, idx = MPI.strcalc_mpi(d[idx:], idx) elif ASYM_ELGAMAL_E == self.alg_pubkey: self.ELGAMAL_gk_modp, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_myk_modp, idx = MPI.strcalc_mpi(d[idx:], idx) else: raise PGPValueError, "Unsupported public key algorithm. Received alg_pubkey->(%s)" % self.alg_pubkey
def fill(self, d): """ """ idx = 0 self.type, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) if self.type in [0x01, 0x03]: self.salt, idx = STN.strcalc(None, d[idx:idx+8], idx) if 0x03 == self.type: c, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.count_code = c self.count = (16 + (c & 15)) << ((c >> 4) + 6) self._d = d[0:idx] #hexify = lambda s: ''.join(['\\x%s' % hex(ord(c))[2:].zfill(2) for c in s]) #print hexify(self._d) self.size = len(self._d)
def fill(self, d): idx = PublicKeyBody.fill(self, d) self._private_idx = idx # marks start of private data self.s2k_usg, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) if 0 == self.s2k_usg: # unencrypted MPIs self.__resolve_secmpi(idx) else: if self.s2k_usg in [254, 255]: # encrypted MPIs self.alg_sym, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.s2k, idx = S2K.strcalc_s2k(d[idx:], idx) if 0 == self.alg_sym: # plaintext or unencrypted data self.__resolve_secmpi(idx) return elif 1 == self.alg_sym: # IDEA [IDEA] self.iv, idx = STN.strcalc(None, d[idx:idx+8], idx) elif 2 == self.alg_sym: # Triple-DES DES-EDE, 168 bit key derived from 192 raise NotImplementedError, "3DES" elif 3 == self.alg_sym: # CAST5 (128 bit key, as per RFC2144) self.iv, idx = STN.strcalc(None, d[idx:idx+8], idx) elif 4 == self.alg_sym: # Blowfish (128 bit key, 16 rounds) self.iv, idx = STN.strcalc(None, d[idx:idx+8], idx) elif self.alg_sym in [5, 6]: # Reserved raise NotImplementedError, "Reserved" elif 7 == self.alg_sym: # AES with 128-bit key [AES] raise NotImplementedError, "AES 128" elif 8 == self.alg_sym: # AES with 192-bit key raise NotImplementedError, "AES 192" elif 9 == self.alg_sym: # AES with 256-bit key raise NotImplementedError, "AES 256" elif 10 == self.alg_sym: # Twofish with 256-bit key [TWOFISH] raise NotImplementedError, "Twofish" elif self.alg_sym in range(100, 111): #100-110 Private/Experimental raise NotImplementedError, "Private/Experimental" else: raise ValueError, "Unsupported symmetric encryption algorithm->(%s)" % (str(self.alg_sym)) else: # s2k usage specifies the symmetric algorithm self.alg_sym = self.s2k_usg self.iv, idx = STN.strcalc(None, d[idx:idx+8], idx) # encrypted data: MPIs + chksum/hash if 3 == self.version and self.s2k_usg in [254, 255]: if 255 == self.s2k_usg: # checksum is stored in the clear self._enc_d = d[:-2] self.chksum = d[-2:] elif 254 == self.s2k_usg: # nothing was specifically mentioned self._enc_d = d[:-20] # about SHA1 in v3/RSA keys, but this self.chksum = d[-20:] # should make sense given the above else: self._enc_d = d[idx:]
def fill(self, d): import struct idx = 0 self._length_d, idx = STN.strcalc(None, d[idx:idx+2], idx) self.bit_length = STN.str2int(self._length_d) self.length = STN.mpilen2int(self._length_d) self._d = d[0:2+self.length] self._int_d = d[idx:idx+self.length] self.size = len(self._d) # explicitly.. i = struct.unpack('>'+str(len(self._int_d))+'s', self._int_d)[0] self.value = STN.str2int(i) if self.check(): pass else: raise self.err[0], self.err[1]
def fill(self, d): import struct idx = 0 self._length_d, idx = STN.strcalc(None, d[idx:idx + 2], idx) self.bit_length = STN.str2int(self._length_d) self.length = STN.mpilen2int(self._length_d) self._d = d[0:2 + self.length] self._int_d = d[idx:idx + self.length] self.size = len(self._d) # explicitly.. i = struct.unpack('>' + str(len(self._int_d)) + 's', self._int_d)[0] self.value = STN.str2int(i) if self.check(): pass else: raise self.err[0], self.err[1]
def __resolve_secmpi(self, idx): d = self._d # 1:RSA (Encrypt or Sign), 2:RSA Encrypt-Only, 3:RSA Sign-Only if self.alg in [1, 2, 3]: self.RSA_d, idx = MPI.strcalc_mpi(d[idx:], idx) self.RSA_p, idx = MPI.strcalc_mpi(d[idx:], idx) self.RSA_q, idx = MPI.strcalc_mpi(d[idx:], idx) self.RSA_u, idx = MPI.strcalc_mpi(d[idx:], idx) self._secmpi_d = self.RSA_d._d + self.RSA_p._d + self.RSA_q._d + self.RSA_u._d # 17:DSA (Digital Signature Algorithm) elif 17 == self.alg: self.DSA_x, idx = MPI.strcalc_mpi(d[idx:], idx) self._secmpi_d = self.DSA_x._d # 16:Elgamal (Encrypt-Only), 20:Elgamal (Encrypt or Sign) elif self.alg in [16, 20]: self.ELGAMAL_x, idx = MPI.strcalc_mpi(d[idx:], idx) self._secmpi_d = self.ELGAMAL_x._d else: self.err = (ValueError, "Unsupported key algorithm. Received alg->(%s)" % (str(self.alg))) if 255 == self.s2k_usg: self.chksum, idx = STN.strcalc(STN.str2int, d[idx:idx+2], idx) else: self.chksum = None
def fill(self, d): self._d = d idx = 0 __version_d = d[idx:idx + 1] self.version, idx = STN.strcalc(STN.str2int, __version_d, idx) if self.version in [2, 3, 4]: __created_d = d[idx:idx + 4] self.created, idx = STN.strcalc(STN.str2int, __created_d, idx) if self.version in [2, 3]: self.__expires_d = d[idx:idx + 2] self.expires, idx = STN.strcalc(STN.str2int, self.__expires_d, idx) __alg_d = d[idx:idx + 1] self.alg, idx = STN.strcalc(STN.str2int, __alg_d, idx) # resolve MPIs if self.alg in [ASYM_RSA_EOS, ASYM_RSA_E, ASYM_RSA_S]: self.RSA_n, idx = MPI.strcalc_mpi(d[idx:], idx) self.RSA_e, idx = MPI.strcalc_mpi(d[idx:], idx) self._mpi_d = self.RSA_n._d + self.RSA_e._d elif ASYM_DSA == self.alg: self.DSA_p, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_q, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_g, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_y, idx = MPI.strcalc_mpi(d[idx:], idx) self._mpi_d = self.DSA_p._d + self.DSA_q._d + self.DSA_g._d + self.DSA_y._d elif self.alg in [ASYM_ELGAMAL_E, ASYM_ELGAMAL_EOS]: self.ELGAMAL_p, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_g, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_y, idx = MPI.strcalc_mpi(d[idx:], idx) self._mpi_d = self.ELGAMAL_p._d + self.ELGAMAL_g._d + self.ELGAMAL_y._d else: raise NotImplementedError( "Unsupported key algorithm. Received alg->(%s)" % self.alg) # set fingerprint if self.version in [2, 3]: integer_data = self.RSA_n._int_d + self.RSA_e._int_d self.fingerprint = md5.new(integer_data).hexdigest().upper() # see fingerprint/id notes in doc/NOTES.txt self.id = STN.str2hex(self.RSA_n._int_d[-8:]) elif 4 == self.version: f = ['\x99'] f_data = ''.join( [__version_d, __created_d, __alg_d, self._mpi_d]) length = len(f_data) hi = (chr((0xffff & length) >> 8)) # high order packet length lo = (chr(0xff & length)) # low order packet length f.append(hi + lo) f.append(f_data) self.fingerprint = sha.new(''.join(f)).hexdigest().upper() # see fingerprint/id notes in doc/NOTES.txt self.id = self.fingerprint[-16:] else: # unsupported packet version raise NotImplementedError("Unsupported key version: %s" % self.version) return idx
def fill(self, d): """Set the Packet instances's data, filling its attributes. :Parameters: - `d`: string of OpenPGP packet data :Returns: Nothing Tag data (d) must be a string of valid OpenPGP packet data (tag, length, body, and possibly partial length/body interlacing). Example: >>> tag = chr(0xb4) # old version, user id (type 13), single octet length >>> length = chr(0x17) # body occupies next 23 octets >>> body = "Tester <*****@*****.**>" >>> pkt = Packet(tag+length+body) >>> pkt.tag.type, pkt.length.size, pkt.body.value 13, 23, 'Tester <*****@*****.**>' """ # Partial Length Mechanics (..elif 1 == self.tag.version..): Body # length is determined locally (with the help of str2int # functions) to accomodate a flow between partial body fragments, # concluding fragments, and complete packet bodies (append to # list, concatenate the list at the end). The actual length object # is determined after the fact and must match up with the body # data recovered in order to pass a selfcheck(). # TODO see how much of the new length logic can use NewLength.data2size. self.tag = Tag(d[0:1]) if 0 == self.tag.version: # old lo = [1, 2, 4, 0][self.tag.length_type] # [length octs][length type] idx = 1 + lo self.length = OldLength(d[1:idx]) if 'UNDEFINED' == self.length.size: self.fill_body(d[idx:]) else: self.fill_body(d[idx:idx+self.length.size]) elif 1 == self.tag.version: # new idx = 1 bodydata, lengthdata = [], [] L1 = d[idx:idx+1] L1_ord = ord(L1) while 224 <= L1_ord <= 254: # catch partials size, idx = STN.strcalc(STN.partial2int, L1, idx) if 0 == len(lengthdata) and 512 > size: raise PGPFormatError("First partial length MUST be at least 512 octets long. Received: length.size->(%s) length.data->(%s)" % (len(lengthdata), hex(L1_ord))) else: lengthdata.append(L1) bodydata.append(d[idx:idx+size]) idx = idx + size L1 = d[idx:idx+1] L1_ord = ord(L1) if L1_ord < 192: size, idx = STN.strcalc(STN.str2int, L1, idx) lengthdata.append(L1) bodydata.append(d[idx:idx+size]) elif 192 <= L1_ord <= 223: lengthdata.append(d[idx:idx+2]) size, idx = STN.strcalc(STN.doubleoct2int, d[idx:idx+2], idx) bodydata.append(d[idx:idx+size]) elif 255 == L1_ord: lengthdata.append(d[idx:idx+5]) size, idx = STN.strcalc(STN.pentoct2int, d[idx:idx+5], idx) bodydata.append(d[idx:idx+size]) else: raise PGPError, "Extreme weirdness. Fix source." self.length = NewLength(''.join(lengthdata)) self.fill_body(''.join(bodydata)) self.size = len(self.tag._d) + len(self.length._d) + len(self.body._d) if self.check(): return 1 else: raise self.err[0], self.err[1]
def fill(self, d): """Set the Packet instances's data, filling its attributes. :Parameters: - `d`: string of OpenPGP packet data :Returns: Nothing Tag data (d) must be a string of valid OpenPGP packet data (tag, length, body, and possibly partial length/body interlacing). Example: >>> tag = chr(0xb4) # old version, user id (type 13), single octet length >>> length = chr(0x17) # body occupies next 23 octets >>> body = "Tester <*****@*****.**>" >>> pkt = Packet(tag+length+body) >>> pkt.tag.type, pkt.length.size, pkt.body.value 13, 23, 'Tester <*****@*****.**>' """ # Partial Length Mechanics (..elif 1 == self.tag.version..): Body # length is determined locally (with the help of str2int # functions) to accomodate a flow between partial body fragments, # concluding fragments, and complete packet bodies (append to # list, concatenate the list at the end). The actual length object # is determined after the fact and must match up with the body # data recovered in order to pass a selfcheck(). # TODO see how much of the new length logic can use NewLength.data2size. self.tag = Tag(d[0:1]) if 0 == self.tag.version: # old lo = [1, 2, 4, 0][self.tag.length_type] # [length octs][length type] idx = 1 + lo self.length = OldLength(d[1:idx]) if 'UNDEFINED' == self.length.size: self.fill_body(d[idx:]) else: self.fill_body(d[idx:idx + self.length.size]) elif 1 == self.tag.version: # new idx = 1 bodydata, lengthdata = [], [] L1 = d[idx:idx + 1] L1_ord = ord(L1) while 224 <= L1_ord <= 254: # catch partials size, idx = STN.strcalc(STN.partial2int, L1, idx) if 0 == len(lengthdata) and 512 > size: raise PGPFormatError( "First partial length MUST be at least 512 octets long. Received: length.size->(%s) length.data->(%s)" % (len(lengthdata), hex(L1_ord))) else: lengthdata.append(L1) bodydata.append(d[idx:idx + size]) idx = idx + size L1 = d[idx:idx + 1] L1_ord = ord(L1) if L1_ord < 192: size, idx = STN.strcalc(STN.str2int, L1, idx) lengthdata.append(L1) bodydata.append(d[idx:idx + size]) elif 192 <= L1_ord <= 223: lengthdata.append(d[idx:idx + 2]) size, idx = STN.strcalc(STN.doubleoct2int, d[idx:idx + 2], idx) bodydata.append(d[idx:idx + size]) elif 255 == L1_ord: lengthdata.append(d[idx:idx + 5]) size, idx = STN.strcalc(STN.pentoct2int, d[idx:idx + 5], idx) bodydata.append(d[idx:idx + size]) else: raise PGPError, "Extreme weirdness. Fix source." self.length = NewLength(''.join(lengthdata)) self.fill_body(''.join(bodydata)) self.size = len(self.tag._d) + len(self.length._d) + len(self.body._d) if self.check(): return 1 else: raise self.err[0], self.err[1]
def fill(self, d): self._d = d version_d = d[0] self.version, idx = STN.strcalc(STN.str2int, d[0], 0) if self.version in [2, 3]: hash_len, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) self.type, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) self.created, idx = STN.strcalc(STN.str2int, d[idx:idx + 4], idx) self.hashed_data = d[2:idx] self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx + 8], idx) self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) self.hashed_subpkts = [] # dummy settings to make searches easier self.unhashed_subpkts = [] # elif 4 == self.version: import struct _type_d, idx = STN.strcalc(None, d[idx:idx + 1], idx) self.type = STN.str2int(_type_d) self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx + 1], idx) # hashed subpackets subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx + 2], idx) self.hashed_subpkts = self.__resolve_subpkts(d[idx:idx + subpkts_len]) # hashed data & trailer - should '>i' ever return more than 4 chars? hashed_data = d[0:idx + subpkts_len] bigend = struct.pack('>i', len(hashed_data))[-4:] self.hashed_data = ''.join( [hashed_data, version_d, '\xff', bigend]) idx = idx + subpkts_len # unhashed subpackets subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx + 2], idx) self.unhashed_subpkts = self.__resolve_subpkts(d[idx:idx + subpkts_len]) idx = idx + subpkts_len # attribute convenience self.keyid = self.__set_subpkt_attr(SIGSUB_SIGNERID) or '' self.created = self.__set_subpkt_attr(SIGSUB_CREATED) or 0 else: raise PGPValueError( "Unsupported signature version. Received->(%s)" % str(self.version)) self.hash_frag, idx = STN.strcalc(None, d[idx:idx + 2], idx) if self.alg_pubkey in [ASYM_RSA_S, ASYM_RSA_EOS]: self.RSA, idx = MPI.strcalc_mpi(d[idx:], idx) elif ASYM_DSA == self.alg_pubkey: self.DSA_r, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_s, idx = MPI.strcalc_mpi(d[idx:], idx) elif self.alg_pubkey in [ASYM_ELGAMAL_EOS]: self.ELGAMAL_a, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_b, idx = MPI.strcalc_mpi(d[idx:], idx) else: raise PGPValueError("Unsupported public-key algorithm (%d)." % self.alg_pubkey)
def fill(self, d): self._d = d version_d = d[0] self.version, idx = STN.strcalc(STN.str2int, d[0], 0) if self.version in [2, 3]: hash_len, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.type, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.created, idx = STN.strcalc(STN.str2int, d[idx:idx+4], idx) self.hashed_data = d[2:idx] self.keyid, idx = STN.strcalc(STN.str2hex, d[idx:idx+8], idx) self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.hashed_subpkts = [] # dummy settings to make searches easier self.unhashed_subpkts = [] # elif 4 == self.version: import struct _type_d, idx = STN.strcalc(None, d[idx:idx+1], idx) self.type = STN.str2int(_type_d) self.alg_pubkey, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) self.alg_hash, idx = STN.strcalc(STN.str2int, d[idx:idx+1], idx) # hashed subpackets subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx+2], idx) self.hashed_subpkts = self.__resolve_subpkts(d[idx:idx+subpkts_len]) # hashed data & trailer - should '>i' ever return more than 4 chars? hashed_data = d[0:idx+subpkts_len] bigend = struct.pack('>i', len(hashed_data))[-4:] self.hashed_data = ''.join([hashed_data, version_d, '\xff', bigend]) idx = idx + subpkts_len # unhashed subpackets subpkts_len, idx = STN.strcalc(STN.str2int, d[idx:idx+2], idx) self.unhashed_subpkts = self.__resolve_subpkts(d[idx:idx+subpkts_len]) idx = idx + subpkts_len # attribute convenience self.keyid = self.__set_subpkt_attr(SIGSUB_SIGNERID) or '' self.created = self.__set_subpkt_attr(SIGSUB_CREATED) or 0 else: raise PGPValueError("Unsupported signature version. Received->(%s)" % str(self.version)) self.hash_frag, idx = STN.strcalc(None, d[idx:idx+2], idx) if self.alg_pubkey in [ASYM_RSA_S, ASYM_RSA_EOS]: self.RSA, idx = MPI.strcalc_mpi(d[idx:], idx) elif ASYM_DSA == self.alg_pubkey: self.DSA_r, idx = MPI.strcalc_mpi(d[idx:], idx) self.DSA_s, idx = MPI.strcalc_mpi(d[idx:], idx) elif self.alg_pubkey in [ASYM_ELGAMAL_EOS]: self.ELGAMAL_a, idx = MPI.strcalc_mpi(d[idx:], idx) self.ELGAMAL_b, idx = MPI.strcalc_mpi(d[idx:], idx) else: raise PGPValueError("Unsupported public-key algorithm (%d)." % self.alg_pubkey)