diff --git a/SPECS/binutils/CVE-2025-69645.patch b/SPECS/binutils/CVE-2025-69645.patch new file mode 100644 index 00000000000..cd82fe43d6e --- /dev/null +++ b/SPECS/binutils/CVE-2025-69645.patch @@ -0,0 +1,126 @@ +From cdb728d4da6184631989b192f1022c219dea7677 Mon Sep 17 00:00:00 2001 +From: Alan Modra +Date: Sun, 30 Nov 2025 12:51:54 +1030 +Subject: [PATCH] PR 33637, abort in byte_get + +When DWARF5 support was added to binutils in commit 77145576fadc, +the loop over CUs in process_debug_info set do_types when finding a +DW_UT_type unit, in order to process the signature and type offset +entries. Unfortunately that broke debug_information/debug_info_p +handling, which previously was allocated and initialised for each unit +in .debug_info. debug_info_p was NULL when processing a DWARF4 +.debug_types section. After the 77145576fadc change it was possible +for debug_infp_p to be non-NULL but point to zeroed data, in +particular a zeroed offset_size. A zero for offset_size led to the +byte_get_little_endian abort triggered by the fuzzer testcase. + +I haven't investigated whether there is any need for a valid +offset_size when processing a non-fuzzed DWARF4 .debug_types section. +Presumably we'd have found that out in the last 6 years if that was +the case. We don't want to change debug_information[] for +.debug_types! + + PR 33637 + * dwarf.c (process_debug_info): Don't change DO_TYPES flag bit + depending on cu_unit_type. Instead test cu_unit_type along + with DO_TYPES to handle signature and type_offset for a type + unit. Move find_cu_tu_set_v2 call a little later. + +Upstream Patch Reference: https://sourceware.org/git/?p=binutils-gdb.git;a=patch;h=cdb728d4da6184631989b192f1022c219dea7677 +--- + binutils/dwarf.c | 18 ++++++------------ + 1 file changed, 6 insertions(+), 12 deletions(-) + +diff --git a/binutils/dwarf.c b/binutils/dwarf.c +index ea83e35a..25013132 100644 +--- a/binutils/dwarf.c ++++ b/binutils/dwarf.c +@@ -3707,8 +3707,6 @@ process_debug_info (struct dwarf_section * section, + + SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end_cu); + +- this_set = find_cu_tu_set_v2 (cu_offset, do_types); +- + if (compunit.cu_version < 5) + { + compunit.cu_unit_type = DW_UT_compile; +@@ -3718,8 +3716,6 @@ process_debug_info (struct dwarf_section * section, + else + { + SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end_cu); +- do_types = (compunit.cu_unit_type == DW_UT_type); +- + SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end_cu); + } + +@@ -3733,6 +3729,7 @@ process_debug_info (struct dwarf_section * section, + SAFE_BYTE_GET_AND_INC (dwo_id, hdrptr, 8, end_cu); + } + ++ this_set = find_cu_tu_set_v2 (cu_offset, do_types); + if (this_set == NULL) + { + abbrev_base = 0; +@@ -3789,8 +3786,6 @@ process_debug_info (struct dwarf_section * section, + + SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end_cu); + +- this_set = find_cu_tu_set_v2 (cu_offset, do_types); +- + if (compunit.cu_version < 5) + { + compunit.cu_unit_type = DW_UT_compile; +@@ -3800,13 +3795,12 @@ process_debug_info (struct dwarf_section * section, + else + { + SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end_cu); +- do_types = (compunit.cu_unit_type == DW_UT_type); +- + SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end_cu); + } + + SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end_cu); + ++ this_set = find_cu_tu_set_v2 (cu_offset, do_types); + if (this_set == NULL) + { + abbrev_base = 0; +@@ -3838,7 +3832,7 @@ process_debug_info (struct dwarf_section * section, + compunit.cu_pointer_size = offset_size; + } + +- if (do_types) ++ if (do_types || compunit.cu_unit_type == DW_UT_type) + { + SAFE_BYTE_GET_AND_INC (signature, hdrptr, 8, end_cu); + SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end_cu); +@@ -3853,7 +3847,7 @@ process_debug_info (struct dwarf_section * section, + if ((do_loc || do_debug_loc || do_debug_ranges || do_debug_info) + && num_debug_info_entries == 0 + && alloc_num_debug_info_entries > unit +- && ! do_types) ++ && !do_types) + { + free_debug_information (&debug_information[unit]); + memset (&debug_information[unit], 0, sizeof (*debug_information)); +@@ -3884,7 +3878,7 @@ process_debug_info (struct dwarf_section * section, + printf (_(" Abbrev Offset: %#" PRIx64 "\n"), + compunit.cu_abbrev_offset); + printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size); +- if (do_types) ++ if (do_types || compunit.cu_unit_type == DW_UT_type) + { + printf (_(" Signature: %#" PRIx64 "\n"), signature); + printf (_(" Type Offset: %#" PRIx64 "\n"), type_offset); +@@ -4121,7 +4115,7 @@ process_debug_info (struct dwarf_section * section, + we need to process .debug_loc and .debug_ranges sections. */ + if ((do_loc || do_debug_loc || do_debug_ranges || do_debug_info) + && num_debug_info_entries == 0 +- && ! do_types) ++ && !do_types) + { + if (num_units > alloc_num_debug_info_entries) + num_debug_info_entries = alloc_num_debug_info_entries; +-- +2.45.4 + diff --git a/SPECS/binutils/CVE-2025-69646.patch b/SPECS/binutils/CVE-2025-69646.patch new file mode 100644 index 00000000000..184b7135abf --- /dev/null +++ b/SPECS/binutils/CVE-2025-69646.patch @@ -0,0 +1,387 @@ +From 598704a00cbac5e85c2bedd363357b5bf6fcee33 Mon Sep 17 00:00:00 2001 +From: Alan Modra +Date: Sat, 22 Nov 2025 09:22:10 +1030 +Subject: [PATCH] PR 33638, debug_rnglists output + +The fuzzed testcase in this PR continuously outputs an error about +the debug_rnglists header. Fixed by taking notice of the error and +stopping output. The patch also limits the length in all cases, not +just when a relocation is present, and limits the offset entry count +read from the header. I removed the warning and the test for relocs +because the code can't work reliably with unresolved relocs in the +length field. + + PR 33638 + * dwarf.c (display_debug_rnglists_list): Return bool. Rename + "inital_length" to plain "length". Verify length is large + enough to read header. Limit length to rest of section. + Similarly limit offset_entry_count. + (display_debug_ranges): Check display_debug_rnglists_unit_header + return status. Stop output on error. + +Upstream Patch Reference: https://sourceware.org/git/?p=binutils-gdb.git;a=patch;h=598704a00cbac5e85c2bedd363357b5bf6fcee33 +--- + binutils/dwarf.c | 264 ++++++++++++++++++++++++++++++++++++----------- + 1 file changed, 201 insertions(+), 63 deletions(-) + +diff --git a/binutils/dwarf.c b/binutils/dwarf.c +index 25013132..6e31c7e1 100644 +--- a/binutils/dwarf.c ++++ b/binutils/dwarf.c +@@ -7964,7 +7964,7 @@ range_entry_compar (const void *ap, const void *bp) + return (a > b) - (b > a); + } + +-static void ++static unsigned char * + display_debug_ranges_list (unsigned char * start, + unsigned char * finish, + unsigned int pointer_size, +@@ -8011,6 +8011,7 @@ display_debug_ranges_list (unsigned char * start, + + putchar ('\n'); + } ++ return start; + } + + static unsigned char * +@@ -8247,23 +8248,123 @@ display_debug_rnglists (struct dwarf_section *section) + putchar ('\n'); + return 1; + } ++static bool ++display_debug_rnglists_unit_header (struct dwarf_section * section, ++ uint64_t * unit_offset, ++ unsigned char * poffset_size) ++{ ++ uint64_t start_offset = *unit_offset; ++ unsigned char * p = section->start + start_offset; ++ unsigned char * finish = section->start + section->size; ++ unsigned char * hdr; ++ uint64_t length; ++ unsigned char segment_selector_size; ++ unsigned int offset_entry_count; ++ unsigned int i; ++ unsigned short version; ++ unsigned char address_size = 0; ++ unsigned char offset_size; ++ ++ /* Get and check the length of the block. */ ++ SAFE_BYTE_GET_AND_INC (length, p, 4, finish); ++ ++ if (length == 0xffffffff) ++ { ++ /* This section is 64-bit DWARF 3. */ ++ SAFE_BYTE_GET_AND_INC (length, p, 8, finish); ++ *poffset_size = offset_size = 8; ++ } ++ else ++ *poffset_size = offset_size = 4; ++ ++ if (length < 8) ++ return false; ++ ++ /* Get the other fields in the header. */ ++ hdr = p; ++ SAFE_BYTE_GET_AND_INC (version, p, 2, finish); ++ SAFE_BYTE_GET_AND_INC (address_size, p, 1, finish); ++ SAFE_BYTE_GET_AND_INC (segment_selector_size, p, 1, finish); ++ SAFE_BYTE_GET_AND_INC (offset_entry_count, p, 4, finish); ++ ++ printf (_(" Table at Offset: %#" PRIx64 ":\n"), start_offset); ++ printf (_(" Length: %#" PRIx64 "\n"), length); ++ printf (_(" DWARF version: %u\n"), version); ++ printf (_(" Address size: %u\n"), address_size); ++ printf (_(" Segment size: %u\n"), segment_selector_size); ++ printf (_(" Offset entries: %u\n"), offset_entry_count); ++ ++ if (length > (size_t) (finish - hdr)) ++ length = finish - hdr; ++ ++ /* Report the next unit offset to the caller. */ ++ *unit_offset = (hdr - section->start) + length; ++ ++ /* Check the fields. */ ++ if (segment_selector_size != 0) ++ { ++ warn (_("The %s section contains " ++ "unsupported segment selector size: %d.\n"), ++ section->name, segment_selector_size); ++ return false; ++ } ++ ++ if (version < 5) ++ { ++ warn (_("Only DWARF version 5+ debug_rnglists info " ++ "is currently supported.\n")); ++ return false; ++ } ++ ++ uint64_t max_off_count = (length - 8) / offset_size; ++ if (offset_entry_count > max_off_count) ++ offset_entry_count = max_off_count; ++ if (offset_entry_count != 0) ++ { ++ printf (_("\n Offsets starting at %#tx:\n"), p - section->start); ++ ++ for (i = 0; i < offset_entry_count; i++) ++ { ++ uint64_t entry; ++ ++ SAFE_BYTE_GET_AND_INC (entry, p, offset_size, finish); ++ printf (_(" [%6u] %#" PRIx64 "\n"), i, entry); ++ } ++ } ++ ++ return true; ++} ++ ++static bool ++is_range_list_for_this_section (bool is_rnglists, unsigned int version) ++{ ++ if (is_rnglists && version > 4) ++ return true; ++ ++ if (!is_rnglists && version < 5) ++ return true; ++ ++ return false; ++} + + static int + display_debug_ranges (struct dwarf_section *section, +- void *file ATTRIBUTE_UNUSED) ++ void *file ATTRIBUTE_UNUSED) + { + unsigned char *start = section->start; + unsigned char *last_start = start; ++ unsigned char *last_end; + uint64_t bytes = section->size; + unsigned char *section_begin = start; + unsigned char *finish = start + bytes; + unsigned int num_range_list, i; + struct range_entry *range_entries; + struct range_entry *range_entry_fill; +- int is_rnglists = strstr (section->name, "debug_rnglists") != NULL; +- /* Initialize it due to a false compiler warning. */ +- unsigned char address_size = 0; ++ bool is_rnglists = strstr (section->name, "debug_rnglists") != NULL; + uint64_t last_offset = 0; ++ uint64_t next_rnglists_cu_offset = 0; ++ unsigned char offset_size; ++ bool ok_header = true; + + if (bytes == 0) + { +@@ -8272,32 +8373,28 @@ display_debug_ranges (struct dwarf_section *section, + } + + introduce (section, false); +- +- if (is_rnglists) +- return display_debug_rnglists (section); + + if (load_debug_info (file) == 0) + { + warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"), +- section->name); ++ section->name); + return 0; + } + + num_range_list = 0; + for (i = 0; i < num_debug_info_entries; i++) +- num_range_list += debug_information [i].num_range_lists; ++ if (is_range_list_for_this_section (is_rnglists, debug_information[i].dwarf_version)) ++ num_range_list += debug_information[i].num_range_lists; + + if (num_range_list == 0) + { + /* This can happen when the file was compiled with -gsplit-debug +- which removes references to range lists from the primary .o file. */ +- printf (_("No range lists in .debug_info section.\n")); ++ which removes references to range lists from the primary .o file. */ ++ printf (_("No range lists referenced by .debug_info section.\n")); + return 1; + } + +- range_entries = (struct range_entry *) +- xmalloc (sizeof (*range_entries) * num_range_list); +- range_entry_fill = range_entries; ++ range_entry_fill = range_entries = XNEWVEC (struct range_entry, num_range_list); + + for (i = 0; i < num_debug_info_entries; i++) + { +@@ -8305,23 +8402,27 @@ display_debug_ranges (struct dwarf_section *section, + unsigned int j; + + for (j = 0; j < debug_info_p->num_range_lists; j++) +- { +- range_entry_fill->ranges_offset = debug_info_p->range_lists[j]; +- range_entry_fill->debug_info_p = debug_info_p; +- range_entry_fill++; +- } +- } +- ++ { ++ if (is_range_list_for_this_section (is_rnglists, debug_info_p->dwarf_version)) ++ { ++ range_entry_fill->ranges_offset = debug_info_p->range_lists[j]; ++ range_entry_fill->debug_info_p = debug_info_p; ++ range_entry_fill++; ++ } ++ } ++ } ++ ++ assert (range_entry_fill >= range_entries); ++ assert (num_range_list >= (unsigned int)(range_entry_fill - range_entries)); ++ num_range_list = range_entry_fill - range_entries; + qsort (range_entries, num_range_list, sizeof (*range_entries), +- range_entry_compar); +- +- if (dwarf_check != 0 && range_entries[0].ranges_offset != 0) +- warn (_("Range lists in %s section start at %#" PRIx64 "\n"), +- section->name, range_entries[0].ranges_offset); ++ range_entry_compar); + + putchar ('\n'); +- printf (_(" Offset Begin End\n")); ++ if (!is_rnglists) ++ printf (_(" Offset Begin End\n")); + ++ last_end = NULL; + for (i = 0; i < num_range_list; i++) + { + struct range_entry *range_entry = &range_entries[i]; +@@ -8331,56 +8432,93 @@ display_debug_ranges (struct dwarf_section *section, + unsigned char *next; + uint64_t base_address; + +- pointer_size = (is_rnglists ? address_size : debug_info_p->pointer_size); ++ pointer_size = debug_info_p->pointer_size; + offset = range_entry->ranges_offset; + base_address = debug_info_p->base_address; + + /* PR 17512: file: 001-101485-0.001:0.1. */ + if (pointer_size < 2 || pointer_size > 8) +- { +- warn (_("Corrupt pointer size (%d) in debug entry at offset %#" PRIx64 "\n"), +- pointer_size, offset); +- continue; +- } ++ { ++ warn (_("Corrupt pointer size (%d) in debug entry at offset %#" PRIx64 "\n"), ++ pointer_size, offset); ++ continue; ++ } + + if (offset > (size_t) (finish - section_begin)) +- { +- warn (_("Corrupt offset (%#" PRIx64 ") in range entry %u\n"), +- offset, i); +- continue; +- } +- +- next = section_begin + offset + debug_info_p->rnglists_base; +- ++ { ++ warn (_("Corrupt offset (%#" PRIx64 ") in range entry %u\n"), ++ offset, i); ++ continue; ++ } ++ ++ /* If we've moved on to the next compile unit in the rnglists section - dump the unit header(s). */ ++ if (is_rnglists && next_rnglists_cu_offset < offset) ++ { ++ while (ok_header && next_rnglists_cu_offset < offset) ++ ok_header = display_debug_rnglists_unit_header (section, ++ &next_rnglists_cu_offset, ++ &offset_size); ++ if (!ok_header) ++ break; ++ printf (_(" Offset Begin End\n")); ++ } ++ ++ next = section_begin + offset; /* Offset is from the section start, the base has already been added. */ ++ ++ if (i == 0) ++ { ++ last_end = section_begin; ++ if (is_rnglists) ++ last_end += 2 * offset_size - 4 + 2 + 1 + 1 + 4; ++ } + /* If multiple DWARF entities reference the same range then we will +- have multiple entries in the `range_entries' list for the same +- offset. Thanks to the sort above these will all be consecutive in +- the `range_entries' list, so we can easily ignore duplicates +- here. */ ++ have multiple entries in the `range_entries' list for the same ++ offset. Thanks to the sort above these will all be consecutive in ++ the `range_entries' list, so we can easily ignore duplicates ++ here. */ + if (i > 0 && last_offset == offset) +- continue; ++ continue; + last_offset = offset; + +- if (dwarf_check != 0 && i > 0) +- { +- if (start < next) +- warn (_("There is a hole [%#tx - %#tx] in %s section.\n"), +- start - section_begin, next - section_begin, section->name); +- else if (start > next) +- { +- if (next == last_start) +- continue; +- warn (_("There is an overlap [%#tx - %#tx] in %s section.\n"), +- start - section_begin, next - section_begin, section->name); +- } +- } ++ if (dwarf_check != 0) ++ { ++ if (start < next) ++ { ++ if (last_end != next) ++ warn (_("There is a hole [%#tx - %#tx] in %s section.\n"), ++ last_end - section_begin, next - section_begin, ++ section->name); ++ } ++ else if (start > next) ++ { ++ if (next == last_start) ++ continue; ++ warn (_("There is an overlap [%#tx - %#tx] in %s section.\n"), ++ start - section_begin, next - section_begin, section->name); ++ } ++ } + + start = next; + last_start = next; + +- display_debug_ranges_list +- (start, finish, pointer_size, offset, base_address); +- } ++ if (is_rnglists) ++ last_end ++ = display_debug_rnglists_list ++ (start, finish, pointer_size, offset, base_address, ++ debug_info_p->addr_base); ++ else ++ last_end ++ = display_debug_ranges_list ++ (start, finish, pointer_size, offset, base_address); ++ } ++ ++ /* Display trailing empty (or unreferenced) compile units, if any. */ ++ if (is_rnglists && ok_header) ++ while (next_rnglists_cu_offset < section->size) ++ if (!display_debug_rnglists_unit_header (section, ++ &next_rnglists_cu_offset, ++ &offset_size)) ++ break; + putchar ('\n'); + + free (range_entries); +-- +2.45.4 + diff --git a/SPECS/binutils/CVE-2025-69649.patch b/SPECS/binutils/CVE-2025-69649.patch new file mode 100644 index 00000000000..2e07a5736e7 --- /dev/null +++ b/SPECS/binutils/CVE-2025-69649.patch @@ -0,0 +1,33 @@ +From 66a3492ce68e1ae45b2489bd9a815c39ea5d7f66 Mon Sep 17 00:00:00 2001 +From: Alan Modra +Date: Mon, 8 Dec 2025 15:58:33 +1030 +Subject: [PATCH] PR 33697, fuzzer segfault + + PR 33697 + * readelf.c (process_relocs): Don't segfault on no sections. + +Upstream Patch Reference: https://sourceware.org/git/?p=binutils-gdb.git;a=patch;h=66a3492ce68e1ae45b2489bd9a815c39ea5d7f66 +--- + binutils/readelf.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/binutils/readelf.c b/binutils/readelf.c +index 97d72d0b..59ca361f 100644 +--- a/binutils/readelf.c ++++ b/binutils/readelf.c +@@ -8490,9 +8490,9 @@ process_relocs (Filedata * filedata) + size_t i; + bool found = false; + +- for (i = 0, section = filedata->section_headers; +- i < filedata->file_header.e_shnum; +- i++, section++) ++ section = filedata->section_headers; ++ if (section != NULL) ++ for (i = 0; i < filedata->file_header.e_shnum; i++, section++) + { + if ( section->sh_type != SHT_RELA + && section->sh_type != SHT_REL +-- +2.45.4 + diff --git a/SPECS/binutils/CVE-2025-69652.patch b/SPECS/binutils/CVE-2025-69652.patch new file mode 100644 index 00000000000..33d03d5b38b --- /dev/null +++ b/SPECS/binutils/CVE-2025-69652.patch @@ -0,0 +1,36 @@ +From 44b79abd0fa12e7947252eb4c6e5d16ed6033e01 Mon Sep 17 00:00:00 2001 +From: Alan Modra +Date: Mon, 8 Dec 2025 16:04:44 +1030 +Subject: [PATCH] PR 33701, abort in byte_get_little_endian + + PR 33701 + * dwarf.c (process_debug_info): Set debug_info_p NULL when + DEBUG_INFO_UNAVAILABLE. + +Upstream Patch Reference: https://sourceware.org/git/?p=binutils-gdb.git;a=patch;h=44b79abd0fa12e7947252eb4c6e5d16ed6033e01 +--- + binutils/dwarf.c | 8 +++++--- + 1 file changed, 5 insertions(+), 3 deletions(-) + +diff --git a/binutils/dwarf.c b/binutils/dwarf.c +index 6e31c7e1..3090af89 100644 +--- a/binutils/dwarf.c ++++ b/binutils/dwarf.c +@@ -4047,9 +4047,11 @@ process_debug_info (struct dwarf_section * section, + break; + } + +- debug_info *debug_info_p = +- (debug_information && unit < alloc_num_debug_info_entries) +- ? debug_information + unit : NULL; ++ debug_info *debug_info_p = NULL; ++ if (debug_information ++ && num_debug_info_entries != DEBUG_INFO_UNAVAILABLE ++ && unit < alloc_num_debug_info_entries) ++ debug_info_p = debug_information + unit; + + assert (!debug_info_p + || (debug_info_p->num_loc_offsets +-- +2.45.4 + diff --git a/SPECS/binutils/binutils.spec b/SPECS/binutils/binutils.spec index 9b3af78c48d..227ea36bf86 100644 --- a/SPECS/binutils/binutils.spec +++ b/SPECS/binutils/binutils.spec @@ -21,7 +21,7 @@ Summary: Contains a linker, an assembler, and other tools Name: binutils Version: 2.41 -Release: 10%{?dist} +Release: 11%{?dist} License: GPLv2+ Vendor: Microsoft Corporation Distribution: Azure Linux @@ -47,6 +47,10 @@ Patch13: CVE-2025-11082.patch Patch14: CVE-2025-11083.patch Patch15: CVE-2025-11412.patch Patch16: CVE-2025-11414.patch +Patch17: CVE-2025-69645.patch +Patch18: CVE-2025-69646.patch +Patch19: CVE-2025-69649.patch +Patch20: CVE-2025-69652.patch Provides: bundled(libiberty) # Moving macro before the "SourceX" tags breaks PR checks parsing the specs. @@ -336,6 +340,9 @@ find %{buildroot} -type f -name "*.la" -delete -print %do_files aarch64-linux-gnu %{build_aarch64} %changelog +* Wed Mar 11 2026 Azure Linux Security Servicing Account - 2.41-11 +- Patch for CVE-2025-69652, CVE-2025-69649, CVE-2025-69646, CVE-2025-69645 + * Thu Oct 16 2025 Azure Linux Security Servicing Account - 2.41-10 - Patch for CVE-2025-11414, CVE-2025-11412 diff --git a/toolkit/resources/manifests/package/pkggen_core_aarch64.txt b/toolkit/resources/manifests/package/pkggen_core_aarch64.txt index 0aa976dbcea..30b4852f77b 100644 --- a/toolkit/resources/manifests/package/pkggen_core_aarch64.txt +++ b/toolkit/resources/manifests/package/pkggen_core_aarch64.txt @@ -13,8 +13,8 @@ zlib-devel-1.3.2-1.azl3.aarch64.rpm file-5.45-1.azl3.aarch64.rpm file-devel-5.45-1.azl3.aarch64.rpm file-libs-5.45-1.azl3.aarch64.rpm -binutils-2.41-10.azl3.aarch64.rpm -binutils-devel-2.41-10.azl3.aarch64.rpm +binutils-2.41-11.azl3.aarch64.rpm +binutils-devel-2.41-11.azl3.aarch64.rpm gmp-6.3.0-1.azl3.aarch64.rpm gmp-devel-6.3.0-1.azl3.aarch64.rpm mpfr-4.2.1-1.azl3.aarch64.rpm diff --git a/toolkit/resources/manifests/package/pkggen_core_x86_64.txt b/toolkit/resources/manifests/package/pkggen_core_x86_64.txt index 0337a6c7966..767354e43ef 100644 --- a/toolkit/resources/manifests/package/pkggen_core_x86_64.txt +++ b/toolkit/resources/manifests/package/pkggen_core_x86_64.txt @@ -13,8 +13,8 @@ zlib-devel-1.3.2-1.azl3.x86_64.rpm file-5.45-1.azl3.x86_64.rpm file-devel-5.45-1.azl3.x86_64.rpm file-libs-5.45-1.azl3.x86_64.rpm -binutils-2.41-10.azl3.x86_64.rpm -binutils-devel-2.41-10.azl3.x86_64.rpm +binutils-2.41-11.azl3.x86_64.rpm +binutils-devel-2.41-11.azl3.x86_64.rpm gmp-6.3.0-1.azl3.x86_64.rpm gmp-devel-6.3.0-1.azl3.x86_64.rpm mpfr-4.2.1-1.azl3.x86_64.rpm diff --git a/toolkit/resources/manifests/package/toolchain_aarch64.txt b/toolkit/resources/manifests/package/toolchain_aarch64.txt index cd1fb23b3f8..418ef3726b6 100644 --- a/toolkit/resources/manifests/package/toolchain_aarch64.txt +++ b/toolkit/resources/manifests/package/toolchain_aarch64.txt @@ -30,9 +30,9 @@ bash-5.2.15-3.azl3.aarch64.rpm bash-debuginfo-5.2.15-3.azl3.aarch64.rpm bash-devel-5.2.15-3.azl3.aarch64.rpm bash-lang-5.2.15-3.azl3.aarch64.rpm -binutils-2.41-10.azl3.aarch64.rpm -binutils-debuginfo-2.41-10.azl3.aarch64.rpm -binutils-devel-2.41-10.azl3.aarch64.rpm +binutils-2.41-11.azl3.aarch64.rpm +binutils-debuginfo-2.41-11.azl3.aarch64.rpm +binutils-devel-2.41-11.azl3.aarch64.rpm bison-3.8.2-1.azl3.aarch64.rpm bison-debuginfo-3.8.2-1.azl3.aarch64.rpm bzip2-1.0.8-1.azl3.aarch64.rpm diff --git a/toolkit/resources/manifests/package/toolchain_x86_64.txt b/toolkit/resources/manifests/package/toolchain_x86_64.txt index 31ec6ab2ceb..a766707b5c2 100644 --- a/toolkit/resources/manifests/package/toolchain_x86_64.txt +++ b/toolkit/resources/manifests/package/toolchain_x86_64.txt @@ -32,10 +32,10 @@ bash-5.2.15-3.azl3.x86_64.rpm bash-debuginfo-5.2.15-3.azl3.x86_64.rpm bash-devel-5.2.15-3.azl3.x86_64.rpm bash-lang-5.2.15-3.azl3.x86_64.rpm -binutils-2.41-10.azl3.x86_64.rpm -binutils-aarch64-linux-gnu-2.41-10.azl3.x86_64.rpm -binutils-debuginfo-2.41-10.azl3.x86_64.rpm -binutils-devel-2.41-10.azl3.x86_64.rpm +binutils-2.41-11.azl3.x86_64.rpm +binutils-aarch64-linux-gnu-2.41-11.azl3.x86_64.rpm +binutils-debuginfo-2.41-11.azl3.x86_64.rpm +binutils-devel-2.41-11.azl3.x86_64.rpm bison-3.8.2-1.azl3.x86_64.rpm bison-debuginfo-3.8.2-1.azl3.x86_64.rpm bzip2-1.0.8-1.azl3.x86_64.rpm @@ -70,7 +70,7 @@ cracklib-lang-2.9.11-1.azl3.x86_64.rpm createrepo_c-1.0.3-1.azl3.x86_64.rpm createrepo_c-debuginfo-1.0.3-1.azl3.x86_64.rpm createrepo_c-devel-1.0.3-1.azl3.x86_64.rpm -cross-binutils-common-2.41-10.azl3.noarch.rpm +cross-binutils-common-2.41-11.azl3.noarch.rpm cross-gcc-common-13.2.0-7.azl3.noarch.rpm curl-8.11.1-5.azl3.x86_64.rpm curl-debuginfo-8.11.1-5.azl3.x86_64.rpm