class ProposalParser:
"""A class to parse IKE and ESP proposal strings into human-readable formats.
This class supports parsing of IKE and ESP proposals, extracting encryption, hash, PRF (for IKE),
and Diffie-Hellman (DH) group information. It also handles the concatenation of these components
into a structured format, indicating whether Perfect Forward Secrecy (PFS) is enabled for ESP proposals.
The parser uses predefined mappings for DH groups, encryption algorithms, hash functions, and Pseudo-Random Functions (PRFs).
It can process a list of proposals and return a formatted string summarizing the cryptographic parameters.
Attributes:
dh_mapping (dict): A mapping of Diffie-Hellman groups to their corresponding identifiers
enc_mapping (dict): A mapping of encryption algorithms to their corresponding identifiers
hash_mapping (dict): A mapping of hash functions to their corresponding identifiers
prf_mapping (dict): A mapping of Pseudo-Random Functions to their corresponding identifiers
"""
def __init__(self):
"""Initialize the parser with mappings for DH groups, encryption, hash, and PRF."""
self.dh_mapping = {
'MODP_768': '1',
'MODP_1024': '2',
'MODP_1536': '5',
'MODP_2048': '14',
'MODP_3072': '15',
'MODP_4096': '16',
'MODP_6144': '17',
'MODP_8192': '18',
'ECP_256': '19',
'ECP_384': '20',
'ECP_521': '21',
'ECP_192': '25',
'ECP_224': '26',
'MODP_1024_160': '22',
'MODP_2048_224': '23',
'MODP_2048_256': '24',
'FFDHE_2048': '256',
'FFDHE_3072': '257',
'FFDHE_4096': '258',
'FFDHE_6144': '259',
'FFDHE_8192': '260',
'ECP_224_BP': '27',
'ECP_256_BP': '28',
'ECP_384_BP': '29',
'ECP_512_BP': '30',
'CURVE_25519': '31',
'CURVE_448': '32',
}
self.enc_mapping = {
'AES_CBC_128': 'AES128',
'AES_CBC_192': 'AES192',
'AES_CBC_256': 'AES256',
'AES_GCM_16_128': 'AES128-GCM-16',
'AES_GCM_16_192': 'AES192-GCM-16',
'AES_GCM_16_256': 'AES256-GCM-16',
'AES_GCM_8_128': 'AES128-GCM-8',
'AES_GCM_8_256': 'AES256-GCM-8',
'AES_GCM_12_128': 'AES128-GCM-12',
'AES_GCM_12_256': 'AES256-GCM-12',
'AES_CCM_16_128': 'AES128-CCM-16',
'AES_CCM_16_256': 'AES256-CCM-16',
'AES_CTR_128': 'AES128-CTR',
'AES_CTR_192': 'AES192-CTR',
'AES_CTR_256': 'AES256-CTR',
'3DES_CBC': '3DES',
'DES_CBC': 'DES',
'CAMELLIA_CBC_128': 'CAMELLIA128',
'CAMELLIA_CBC_256': 'CAMELLIA256',
'CHACHA20_POLY1305': 'CHACHA20-POLY1305',
'BLOWFISH_CBC': 'BLOWFISH',
'CAST5_CBC': 'CAST5',
}
self.hash_mapping = {
'HMAC_MD5': 'MD5',
'HMAC_MD5_96': 'MD5',
'HMAC_SHA1': 'SHA1',
'HMAC_SHA1_96': 'SHA1',
'HMAC_SHA2_256': 'SHA2-256',
'HMAC_SHA2_256_128': 'SHA2-256',
'HMAC_SHA2_384': 'SHA2-384',
'HMAC_SHA2_384_192': 'SHA2-384',
'HMAC_SHA2_512': 'SHA2-512',
'HMAC_SHA2_512_256': 'SHA2-512',
'HMAC_SHA3_224': 'SHA3-224',
'HMAC_SHA3_256': 'SHA3-256',
'HMAC_SHA3_384': 'SHA3-384',
'HMAC_SHA3_512': 'SHA3-512',
'AES_GMAC_128': 'GMAC-128',
'AES_GMAC_192': 'GMAC-192',
'AES_GMAC_256': 'GMAC-256',
'POLY1305': 'POLY1305',
}
self.prf_mapping = {
'PRF_HMAC_MD5': 'MD5',
'PRF_HMAC_SHA1': 'SHA1',
'PRF_HMAC_SHA2_256': 'SHA2-256',
'PRF_HMAC_SHA2_384': 'SHA2-384',
'PRF_HMAC_SHA2_512': 'SHA2-512',
'PRF_AES128_CMAC': 'AES128-CMAC',
'PRF_AES128_XCBC': 'AES128-XCBC',
'PRF_HMAC_SHA3_224': 'SHA3-224',
'PRF_HMAC_SHA3_256': 'SHA3-256',
'PRF_HMAC_SHA3_384': 'SHA3-384',
'PRF_HMAC_SHA3_512': 'SHA3-512',
}
def _categorize_component(self, component, is_ike):
"""Categorize a proposal component into encryption, hash, PRF, or DH group."""
enc_keywords = ['AES_CBC', 'AES_GCM', 'AES_CTR', 'CHACHA20', 'BLOWFISH', 'CAST5', 'DES', '3DES', 'CAMELLIA']
hash_keywords = ['HMAC_SHA', 'HMAC_MD5', 'POLY1305', 'AES_GMAC']
dh_keywords = ['MODP_', 'ECP_', 'FFDHE_', 'CURVE_']
if (component in self.enc_mapping or any(s in component for s in enc_keywords)):
return 'encryption', component
elif is_ike and 'PRF_' in component:
return 'prf', component
elif (component in self.hash_mapping or any(s in component for s in hash_keywords)) and not component.startswith("PRF_"):
return 'hash', component
elif (component in self.dh_mapping or any(s in component for s in dh_keywords)):
return 'dh_group', component
elif component == 'NO_EXT_SEQ':
return 'skip', component
else:
return 'unknown', component
def _map_encryption(self, enc_components, result):
"""Map encryption components to their corresponding identifiers."""
for enc in enc_components:
mapped_enc = self.enc_mapping.get(enc, 'Unknown')
if mapped_enc != 'Unknown' and mapped_enc not in result['encryption']:
result['encryption'].append(mapped_enc)
def _map_hash_and_prf(self, enc_components, hash_components, prf_components, result):
"""Map hash and PRF components, handling AEAD ciphers."""
if not any(enc.startswith('AES_GCM') or enc.startswith('AES_CCM') or enc == 'CHACHA20_POLY1305' for enc in enc_components):
for hash_val in hash_components:
mapped_hash = self.hash_mapping.get(hash_val, 'Unknown')
if mapped_hash not in result['hash']:
result['hash'].append(mapped_hash)
else:
result['hash'].append('None')
for prf in prf_components:
mapped_prf = self.prf_mapping.get(prf, 'Unknown')
if mapped_prf not in result['prf']:
result['prf'].append(mapped_prf)
def _map_dh_group(self, dh_components, result):
"""Map Diffie-Hellman group components to their corresponding identifiers."""
for dh in dh_components:
mapped_dh = self.dh_mapping.get(dh)
if mapped_dh != 'None' and mapped_dh not in result['dh_group']:
result['dh_group'].append(mapped_dh)
def parse_ike_proposal(self, proposal):
"""
Parse an IKE or ESP proposal string into a structured format.
Args:
proposal (str): The proposal string, e.g., "IKE:AES_CBC_256/HMAC_SHA2_256/PRF_HMAC_SHA2_256/MODP_2048"
Returns:
dict: A dictionary with keys 'encryption', 'hash', 'prf', and 'dh_group'
"""
components = proposal.split('/')
result = {
'encryption': [],
'hash': [],
'prf': [],
'dh_group': []
}
is_ike = proposal.startswith('IKE:')
is_esp = proposal.startswith('ESP:')
if is_ike or is_esp:
components[0] = components[0].replace('IKE:', '').replace('ESP:', '')
enc_components = []
hash_components = []
prf_components = []
dh_components = []
unknown_components = []
for component in components:
category, value = self._categorize_component(component, is_ike)
if category == 'encryption':
enc_components.append(value)
elif category == 'hash':
hash_components.append(value)
elif category == 'prf':
prf_components.append(value)
elif category == 'dh_group':
dh_components.append(value)
elif category == 'unknown':
unknown_components.append(value)
self._map_encryption(enc_components, result)
self._map_hash_and_prf(enc_components, hash_components, prf_components, result)
self._map_dh_group(dh_components, result)
if is_esp:
result['prf'] = ['None']
if not result['encryption']:
result['encryption'] = ['Unknown']
if not result['hash']:
result['hash'] = ['None']
if not result['prf']:
result['prf'] = ['None']
if not result['dh_group']:
result['dh_group'] = ['None']
return result
def collect_components(self, proposals):
"""Collect unique encryption, hash, PRF, and DH group components from a list of proposals."""
enc_set = set()
hash_set = set()
prf_set = set()
dh_set = set()
all_aead = True
for proposal in proposals:
parsed = self.parse_ike_proposal(proposal.strip())
enc_set.update(parsed['encryption'])
if not any('GCM' in enc or 'CCM' in enc or 'CHACHA20' in enc for enc in parsed['encryption']):
hash_set.update(parsed['hash'])
all_aead = False
prf_set.update(parsed['prf'])
if parsed['dh_group'] != ['None']:
dh_set.update(parsed['dh_group'])
if all_aead and not hash_set:
hash_set.add('None')
return enc_set, hash_set, prf_set, dh_set
def format_output(self, enc_set, hash_set, prf_set, dh_set, is_ike):
"""Format the collected components into a human-readable string."""
enc_list = sorted(list(enc_set))
hash_list = sorted(list(hash_set))
prf_list = sorted(list(prf_set))
dh_list = sorted(list(dh_set), key=lambda x: int(x))
pfs_status = "PFS: Enabled" if dh_set and not is_ike else "PFS: None"
enc_part = f"Encryption: {', '.join(enc_list)}" if enc_list else "Encryption: None"
hash_part = f"Hash: {', '.join(hash_list)}" if hash_list else "Hash: None"
dh_part = f"DH Group(s): {', '.join(dh_list)}" if dh_list else "DH Group(s): None"
prf_part = f"PRF: {', '.join(prf_list)}" if prf_list else "PRF: None"
if is_ike:
return f"{enc_part} {hash_part} {prf_part} {dh_part}"
else:
return f"{enc_part} {hash_part} {dh_part} {pfs_status}"
def process_proposals(self, proposal_list):
"""
Process a list of IKE or ESP proposals, concatenating encryption, hash, PRF (for IKE only),
and DH group values, and indicate whether PFS is enabled for ESP proposals only.
Args:
proposal_list (str): Comma-separated string of IKE or ESP proposals
Returns:
str: Formatted string with concatenated encryption, hash, PRF (for IKE), DH groups, and PFS status (for ESP)
"""
if proposal_list is None:
return "No proposals provided"
if not proposal_list:
return "No proposals provided"
if not (proposal_list.startswith('IKE:') or proposal_list.startswith('ESP:')):
return "Invalid proposal format. Proposals must be of type 'IKE' for Phase 1 or 'ESP' for Phase 2"
proposal_list = proposal_list.replace(',', ', ')
proposals = proposal_list.strip().split(', ')
is_ike = any(proposal.startswith('IKE:') for proposal in proposals)
enc_set, hash_set, prf_set, dh_set = self.collect_components(proposals)
return self.format_output(enc_set, hash_set, prf_set, dh_set, is_ike)
if __name__ == "__main__":
parser = ProposalParser()
proposal = "IKE:AES_GCM_16_256/MODP_2048/NO_EXT_SEQ"
print(parser.process_proposals(proposal))