use crate::{BuildStrategy, CompatibilityFloor, TargetPolicy};
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};
use std::path::Path;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FloorUnverifiedReason {
PendingInspection,
UnreadableCandidate,
MalformedCandidate,
NoVersionRequirement,
UnrecognizedVersionRequirement,
FloorKindNotVerifiable,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FloorVerificationStatus {
NotDeclared,
ToolchainBound,
Verified,
Unverified(FloorUnverifiedReason),
NotSatisfied,
}
impl Default for FloorVerificationStatus {
fn default() -> Self {
FloorVerificationStatus::NotDeclared
}
}
pub fn planned_floor_status(policy: &TargetPolicy) -> FloorVerificationStatus {
match policy.floor {
CompatibilityFloor::None => FloorVerificationStatus::NotDeclared,
CompatibilityFloor::Glibc { .. } => match policy.strategy {
BuildStrategy::CargoZigbuild => FloorVerificationStatus::ToolchainBound,
BuildStrategy::NativeCargo => {
FloorVerificationStatus::Unverified(FloorUnverifiedReason::PendingInspection)
}
},
CompatibilityFloor::Macos { .. } => {
FloorVerificationStatus::Unverified(FloorUnverifiedReason::FloorKindNotVerifiable)
}
}
}
pub fn floor_status_admissible(
floor: &CompatibilityFloor,
strategy: BuildStrategy,
status: FloorVerificationStatus,
) -> bool {
match (floor, strategy) {
(CompatibilityFloor::None, _) => status == FloorVerificationStatus::NotDeclared,
(CompatibilityFloor::Glibc { .. }, BuildStrategy::CargoZigbuild) => {
status == FloorVerificationStatus::ToolchainBound
}
(CompatibilityFloor::Glibc { .. }, BuildStrategy::NativeCargo) => matches!(
status,
FloorVerificationStatus::Verified
| FloorVerificationStatus::Unverified(_)
| FloorVerificationStatus::NotSatisfied
),
(CompatibilityFloor::Macos { .. }, _) => {
matches!(status, FloorVerificationStatus::Unverified(_))
}
}
}
const MAX_ELF_HEADER: usize = 64;
const MAX_ELF_PROGRAM_HEADERS: usize = 256;
const MAX_ELF_DYNAMIC_ENTRIES: usize = 1024;
const MAX_ELF_VERSION_REQUIREMENTS: usize = 256;
const MAX_ELF_VERSION_AUXILIARIES: usize = 256;
const MAX_ELF_VERSION_NAME: usize = 64;
const PT_LOAD: u32 = 1;
const PT_DYNAMIC: u32 = 2;
const DT_NULL: u64 = 0;
const DT_STRTAB: u64 = 5;
const DT_VERNEED: u64 = 0x6ffffffe;
const DT_VERNEEDNUM: u64 = 0x6fffffff;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum FloorReadError {
NotAnElf,
Unreadable,
Malformed,
BoundExceeded,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
struct GlibcVersion {
major: u16,
minor: u16,
patch: u16,
}
struct ElfHeader {
class64: bool,
little_endian: bool,
program_header_offset: u64,
program_header_size: u16,
program_header_count: u16,
}
struct ProgramSegment {
kind: u32,
offset: u64,
vaddr: u64,
filesz: u64,
}
fn read_exact_at(file: &mut File, offset: u64, buffer: &mut [u8]) -> Result<(), FloorReadError> {
file.seek(SeekFrom::Start(offset))
.map_err(|_| FloorReadError::Unreadable)?;
match file.read_exact(buffer) {
Ok(()) => Ok(()),
Err(error) if error.kind() == std::io::ErrorKind::UnexpectedEof => {
Err(FloorReadError::Malformed)
}
Err(_) => Err(FloorReadError::Unreadable),
}
}
fn u16_at(bytes: &[u8], offset: usize, little_endian: bool) -> u16 {
let raw = [bytes[offset], bytes[offset + 1]];
if little_endian {
u16::from_le_bytes(raw)
} else {
u16::from_be_bytes(raw)
}
}
fn u32_at(bytes: &[u8], offset: usize, little_endian: bool) -> u32 {
let raw = [
bytes[offset],
bytes[offset + 1],
bytes[offset + 2],
bytes[offset + 3],
];
if little_endian {
u32::from_le_bytes(raw)
} else {
u32::from_be_bytes(raw)
}
}
fn u64_at(bytes: &[u8], offset: usize, little_endian: bool) -> u64 {
let mut raw = [0u8; 8];
raw.copy_from_slice(&bytes[offset..offset + 8]);
if little_endian {
u64::from_le_bytes(raw)
} else {
u64::from_be_bytes(raw)
}
}
fn parse_elf_header(file: &mut File, length: u64) -> Result<ElfHeader, FloorReadError> {
let mut header = [0u8; MAX_ELF_HEADER];
let wanted = length.min(MAX_ELF_HEADER as u64) as usize;
file.read_exact(&mut header[..wanted])
.map_err(|_| FloorReadError::Malformed)?;
if wanted < 6 {
return Err(FloorReadError::Malformed);
}
if &header[..4] != b"\x7fELF" {
return Err(FloorReadError::NotAnElf);
}
let class64 = match header[4] {
1 => false,
2 => true,
_ => return Err(FloorReadError::Malformed),
};
let little_endian = match header[5] {
1 => true,
2 => false,
_ => return Err(FloorReadError::Malformed),
};
let minimum = if class64 { 64 } else { 52 };
if length < minimum as u64 || wanted < minimum {
return Err(FloorReadError::Malformed);
}
let (program_header_offset, program_header_size, program_header_count) = if class64 {
(
u64_at(&header, 32, little_endian),
u16_at(&header, 54, little_endian),
u16_at(&header, 56, little_endian),
)
} else {
(
u32_at(&header, 28, little_endian) as u64,
u16_at(&header, 42, little_endian),
u16_at(&header, 44, little_endian),
)
};
Ok(ElfHeader {
class64,
little_endian,
program_header_offset,
program_header_size,
program_header_count,
})
}
fn read_program_segments(
file: &mut File,
header: &ElfHeader,
length: u64,
) -> Result<Vec<ProgramSegment>, FloorReadError> {
if header.program_header_count == 0 {
return Ok(Vec::new());
}
if header.program_header_count == 0xffff {
return Err(FloorReadError::Malformed);
}
if header.program_header_count as usize > MAX_ELF_PROGRAM_HEADERS {
return Err(FloorReadError::BoundExceeded);
}
let expected_size = if header.class64 { 56 } else { 32 };
if header.program_header_size != expected_size {
return Err(FloorReadError::Malformed);
}
let count = header.program_header_count as u64;
let table_end = count
.checked_mul(header.program_header_size as u64)
.and_then(|bytes| header.program_header_offset.checked_add(bytes))
.ok_or(FloorReadError::Malformed)?;
if table_end > length {
return Err(FloorReadError::Malformed);
}
let mut segments = Vec::with_capacity(count as usize);
for index in 0..count {
let offset = header.program_header_offset + index * header.program_header_size as u64;
let mut buffer = [0u8; 56];
read_exact_at(file, offset, &mut buffer[..expected_size as usize])?;
let segment = if header.class64 {
ProgramSegment {
kind: u32_at(&buffer, 0, header.little_endian),
offset: u64_at(&buffer, 8, header.little_endian),
vaddr: u64_at(&buffer, 16, header.little_endian),
filesz: u64_at(&buffer, 32, header.little_endian),
}
} else {
ProgramSegment {
kind: u32_at(&buffer, 0, header.little_endian),
offset: u32_at(&buffer, 4, header.little_endian) as u64,
vaddr: u32_at(&buffer, 8, header.little_endian) as u64,
filesz: u32_at(&buffer, 16, header.little_endian) as u64,
}
};
segments.push(segment);
}
Ok(segments)
}
fn read_dynamic_entries(
file: &mut File,
header: &ElfHeader,
dynamic: &ProgramSegment,
length: u64,
) -> Result<Vec<(u64, u64)>, FloorReadError> {
let entry_size = if header.class64 { 16 } else { 8 };
let count = dynamic.filesz / entry_size as u64;
if count > MAX_ELF_DYNAMIC_ENTRIES as u64 {
return Err(FloorReadError::BoundExceeded);
}
let table_bytes = count * entry_size as u64;
let table_end = dynamic
.offset
.checked_add(table_bytes)
.ok_or(FloorReadError::Malformed)?;
if table_end > length {
return Err(FloorReadError::Malformed);
}
let mut buffer = vec![0u8; table_bytes as usize];
read_exact_at(file, dynamic.offset, &mut buffer)?;
let mut entries = Vec::new();
for index in 0..count as usize {
let base = index * entry_size;
let (tag, value) = if header.class64 {
(
u64_at(&buffer, base, header.little_endian),
u64_at(&buffer, base + 8, header.little_endian),
)
} else {
(
u32_at(&buffer, base, header.little_endian) as u64,
u32_at(&buffer, base + 4, header.little_endian) as u64,
)
};
if tag == DT_NULL {
break;
}
entries.push((tag, value));
}
Ok(entries)
}
fn map_vaddr(segments: &[ProgramSegment], vaddr: u64) -> Result<u64, FloorReadError> {
for segment in segments.iter().filter(|segment| segment.kind == PT_LOAD) {
let end = segment
.vaddr
.checked_add(segment.filesz)
.ok_or(FloorReadError::Malformed)?;
if vaddr >= segment.vaddr && vaddr < end {
return segment
.offset
.checked_add(vaddr - segment.vaddr)
.ok_or(FloorReadError::Malformed);
}
}
Err(FloorReadError::Malformed)
}
fn read_version_name(
file: &mut File,
strtab_offset: u64,
name_offset: u64,
length: u64,
) -> Result<String, FloorReadError> {
let start = strtab_offset
.checked_add(name_offset)
.ok_or(FloorReadError::Malformed)?;
if start >= length {
return Err(FloorReadError::Malformed);
}
let available = (length - start).min(MAX_ELF_VERSION_NAME as u64) as usize;
let mut buffer = [0u8; MAX_ELF_VERSION_NAME];
read_exact_at(file, start, &mut buffer[..available])?;
let end = buffer[..available]
.iter()
.position(|byte| *byte == 0)
.ok_or(FloorReadError::Malformed)?;
Ok(String::from_utf8_lossy(&buffer[..end]).into_owned())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum GlibcVersionName {
NotGlibc,
Numeric(GlibcVersion),
Unrecognized,
}
fn parse_glibc_version(name: &str) -> GlibcVersionName {
let Some(rest) = name.strip_prefix("GLIBC_") else {
return GlibcVersionName::NotGlibc;
};
let parts: Vec<&str> = rest.split('.').collect();
if parts.len() < 2 || parts.len() > 3 {
return GlibcVersionName::Unrecognized;
}
let mut numbers = [0u16; 3];
for (index, part) in parts.iter().enumerate() {
if part.is_empty() || part.len() > 5 || !part.bytes().all(|byte| byte.is_ascii_digit()) {
return GlibcVersionName::Unrecognized;
}
let Ok(number) = part.parse::<u16>() else {
return GlibcVersionName::Unrecognized;
};
numbers[index] = number;
}
GlibcVersionName::Numeric(GlibcVersion {
major: numbers[0],
minor: numbers[1],
patch: numbers[2],
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct GlibcRequirements {
highest: Option<GlibcVersion>,
unrecognized: bool,
}
fn read_glibc_requirement(path: &Path) -> Result<GlibcRequirements, FloorReadError> {
let mut file = File::open(path).map_err(|_| FloorReadError::Unreadable)?;
let length = file
.metadata()
.map_err(|_| FloorReadError::Unreadable)?
.len();
let header = parse_elf_header(&mut file, length)?;
let segments = read_program_segments(&mut file, &header, length)?;
let Some(dynamic) = segments.iter().find(|segment| segment.kind == PT_DYNAMIC) else {
return Ok(GlibcRequirements {
highest: None,
unrecognized: false,
});
};
let entries = read_dynamic_entries(&mut file, &header, dynamic, length)?;
let find = |tag: u64| {
entries
.iter()
.find(|(entry, _)| *entry == tag)
.map(|(_, value)| *value)
};
let Some(verneed_vaddr) = find(DT_VERNEED) else {
return Ok(GlibcRequirements {
highest: None,
unrecognized: false,
});
};
let strtab_vaddr = find(DT_STRTAB).ok_or(FloorReadError::Malformed)?;
let requirement_count = find(DT_VERNEEDNUM);
if requirement_count.is_some_and(|count| count > MAX_ELF_VERSION_REQUIREMENTS as u64) {
return Err(FloorReadError::BoundExceeded);
}
let strtab_offset = map_vaddr(&segments, strtab_vaddr)?;
let verneed_offset = map_vaddr(&segments, verneed_vaddr)?;
if verneed_offset >= length {
return Err(FloorReadError::Malformed);
}
let mut highest: Option<GlibcVersion> = None;
let mut unrecognized = false;
let mut requirement_offset = verneed_offset;
let mut requirements = 0usize;
loop {
if requirements >= MAX_ELF_VERSION_REQUIREMENTS {
return Err(FloorReadError::BoundExceeded);
}
let mut requirement = [0u8; 16];
read_exact_at(&mut file, requirement_offset, &mut requirement)?;
let auxiliary_count = u16_at(&requirement, 2, header.little_endian);
let auxiliary_offset = u32_at(&requirement, 8, header.little_endian) as u64;
let next_requirement = u32_at(&requirement, 12, header.little_endian) as u64;
let mut auxiliary_offset = requirement_offset
.checked_add(auxiliary_offset)
.ok_or(FloorReadError::Malformed)?;
for index in 0..auxiliary_count as usize {
if index >= MAX_ELF_VERSION_AUXILIARIES {
return Err(FloorReadError::BoundExceeded);
}
let mut auxiliary = [0u8; 16];
read_exact_at(&mut file, auxiliary_offset, &mut auxiliary)?;
let name_offset = u32_at(&auxiliary, 8, header.little_endian) as u64;
let next_auxiliary = u32_at(&auxiliary, 12, header.little_endian) as u64;
let name = read_version_name(&mut file, strtab_offset, name_offset, length)?;
match parse_glibc_version(&name) {
GlibcVersionName::Numeric(version) => {
if highest.is_none_or(|current| version > current) {
highest = Some(version);
}
}
GlibcVersionName::Unrecognized => unrecognized = true,
GlibcVersionName::NotGlibc => {}
}
if next_auxiliary == 0 {
break;
}
auxiliary_offset = auxiliary_offset
.checked_add(next_auxiliary)
.ok_or(FloorReadError::Malformed)?;
}
if next_requirement == 0 {
break;
}
requirement_offset = requirement_offset
.checked_add(next_requirement)
.ok_or(FloorReadError::Malformed)?;
requirements += 1;
}
Ok(GlibcRequirements {
highest,
unrecognized,
})
}
pub(crate) fn inspect_candidate_floor(
path: &Path,
floor: &CompatibilityFloor,
strategy: BuildStrategy,
) -> FloorVerificationStatus {
match floor {
CompatibilityFloor::None => FloorVerificationStatus::NotDeclared,
CompatibilityFloor::Macos { .. } => {
FloorVerificationStatus::Unverified(FloorUnverifiedReason::FloorKindNotVerifiable)
}
CompatibilityFloor::Glibc { major, minor } => match strategy {
BuildStrategy::CargoZigbuild => FloorVerificationStatus::ToolchainBound,
BuildStrategy::NativeCargo => {
let declared = GlibcVersion {
major: *major,
minor: *minor,
patch: 0,
};
match read_glibc_requirement(path) {
Ok(requirements) => {
if let Some(required) = requirements.highest {
if required > declared {
FloorVerificationStatus::NotSatisfied
} else if requirements.unrecognized {
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::UnrecognizedVersionRequirement,
)
} else {
FloorVerificationStatus::Verified
}
} else if requirements.unrecognized {
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::UnrecognizedVersionRequirement,
)
} else {
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::NoVersionRequirement,
)
}
}
Err(FloorReadError::NotAnElf | FloorReadError::Unreadable) => {
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::UnreadableCandidate,
)
}
Err(FloorReadError::Malformed | FloorReadError::BoundExceeded) => {
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::MalformedCandidate,
)
}
}
}
},
}
}
fn reason_rank(reason: FloorUnverifiedReason) -> u8 {
match reason {
FloorUnverifiedReason::UnreadableCandidate => 5,
FloorUnverifiedReason::MalformedCandidate => 4,
FloorUnverifiedReason::UnrecognizedVersionRequirement => 3,
FloorUnverifiedReason::NoVersionRequirement => 2,
FloorUnverifiedReason::FloorKindNotVerifiable => 1,
FloorUnverifiedReason::PendingInspection => 0,
}
}
fn status_rank(status: FloorVerificationStatus) -> (u8, u8) {
match status {
FloorVerificationStatus::NotSatisfied => (5, 0),
FloorVerificationStatus::Unverified(reason) => (4, reason_rank(reason)),
FloorVerificationStatus::Verified => (3, 0),
FloorVerificationStatus::ToolchainBound => (2, 0),
FloorVerificationStatus::NotDeclared => (1, 0),
}
}
pub(crate) fn aggregate_floor_status(
statuses: &[FloorVerificationStatus],
) -> FloorVerificationStatus {
let mut combined: Option<FloorVerificationStatus> = None;
for status in statuses {
combined = Some(match combined {
None => *status,
Some(current) => {
if status_rank(*status) > status_rank(current) {
*status
} else {
current
}
}
});
}
combined.unwrap_or(FloorVerificationStatus::Unverified(
FloorUnverifiedReason::UnreadableCandidate,
))
}
#[cfg(test)]
pub(crate) mod test_support {
use super::{DT_NULL, DT_STRTAB, DT_VERNEED, DT_VERNEEDNUM};
pub(crate) struct ElfBuilder {
class64: bool,
little_endian: bool,
versions: Vec<String>,
program_header_count: Option<u16>,
dynamic_filesz: Option<u64>,
program_header_offset: Option<u64>,
}
impl ElfBuilder {
pub(crate) fn new(class64: bool, little_endian: bool) -> Self {
Self {
class64,
little_endian,
versions: Vec::new(),
program_header_count: None,
dynamic_filesz: None,
program_header_offset: None,
}
}
pub(crate) fn versions(mut self, versions: &[&str]) -> Self {
self.versions = versions.iter().map(|value| (*value).to_owned()).collect();
self
}
pub(crate) fn program_header_count(mut self, count: u16) -> Self {
self.program_header_count = Some(count);
self
}
pub(crate) fn dynamic_filesz(mut self, filesz: u64) -> Self {
self.dynamic_filesz = Some(filesz);
self
}
pub(crate) fn program_header_offset(mut self, offset: u64) -> Self {
self.program_header_offset = Some(offset);
self
}
fn put_u16(&self, bytes: &mut [u8], offset: usize, value: u16) {
let raw = if self.little_endian {
value.to_le_bytes()
} else {
value.to_be_bytes()
};
bytes[offset..offset + 2].copy_from_slice(&raw);
}
fn put_u32(&self, bytes: &mut [u8], offset: usize, value: u32) {
let raw = if self.little_endian {
value.to_le_bytes()
} else {
value.to_be_bytes()
};
bytes[offset..offset + 4].copy_from_slice(&raw);
}
fn put_u64(&self, bytes: &mut [u8], offset: usize, value: u64) {
let raw = if self.little_endian {
value.to_le_bytes()
} else {
value.to_be_bytes()
};
bytes[offset..offset + 8].copy_from_slice(&raw);
}
pub(crate) fn build(self) -> Vec<u8> {
let header_size = if self.class64 { 64 } else { 52 };
let program_header_size = if self.class64 { 56 } else { 32 };
let dynamic_entry_size = if self.class64 { 16 } else { 8 };
let dynamic_entries = if self.versions.is_empty() { 2 } else { 4 };
let mut bytes = vec![0u8; header_size];
bytes.resize(bytes.len() + 2 * program_header_size, 0);
let dynamic_offset = bytes.len() as u64;
bytes.resize(bytes.len() + dynamic_entries * dynamic_entry_size, 0);
let verneed_offset = bytes.len() as u64;
let verneed_size = if self.versions.is_empty() {
0
} else {
16 * (1 + self.versions.len())
};
bytes.resize(bytes.len() + verneed_size, 0);
let strtab_offset = bytes.len() as u64;
let mut string_table = Vec::new();
let mut name_offsets = Vec::new();
for version in &self.versions {
name_offsets.push(string_table.len() as u32);
string_table.extend_from_slice(version.as_bytes());
string_table.push(0);
}
bytes.extend_from_slice(&string_table);
let total = bytes.len() as u64;
bytes[..4].copy_from_slice(b"\x7fELF");
bytes[4] = if self.class64 { 2 } else { 1 };
bytes[5] = if self.little_endian { 1 } else { 2 };
bytes[6] = 1;
self.put_u16(&mut bytes, 16, 2); self.put_u16(&mut bytes, 18, if self.class64 { 62 } else { 40 }); self.put_u32(&mut bytes, 20, 1); let program_header_offset = self.program_header_offset.unwrap_or(header_size as u64);
if self.class64 {
self.put_u64(&mut bytes, 32, program_header_offset);
self.put_u16(&mut bytes, 52, header_size as u16);
self.put_u16(&mut bytes, 54, program_header_size as u16);
self.put_u16(&mut bytes, 56, self.program_header_count.unwrap_or(2));
} else {
self.put_u32(&mut bytes, 28, program_header_offset as u32);
self.put_u16(&mut bytes, 40, header_size as u16);
self.put_u16(&mut bytes, 42, program_header_size as u16);
self.put_u16(&mut bytes, 44, self.program_header_count.unwrap_or(2));
}
let first = header_size;
let second = header_size + program_header_size;
let put_segment = |bytes: &mut Vec<u8>,
at: usize,
kind: u32,
offset: u64,
vaddr: u64,
filesz: u64| {
if self.class64 {
self.put_u32(bytes, at, kind);
self.put_u32(bytes, at + 4, 4);
self.put_u64(bytes, at + 8, offset);
self.put_u64(bytes, at + 16, vaddr);
self.put_u64(bytes, at + 24, vaddr);
self.put_u64(bytes, at + 32, filesz);
self.put_u64(bytes, at + 40, filesz);
self.put_u64(bytes, at + 48, 0x1000);
} else {
self.put_u32(bytes, at, kind);
self.put_u32(bytes, at + 4, offset as u32);
self.put_u32(bytes, at + 8, vaddr as u32);
self.put_u32(bytes, at + 12, vaddr as u32);
self.put_u32(bytes, at + 16, filesz as u32);
self.put_u32(bytes, at + 20, filesz as u32);
self.put_u32(bytes, at + 24, 4);
self.put_u32(bytes, at + 28, 0x1000);
}
};
put_segment(&mut bytes, first, 1, 0, 0, total);
let dynamic_size = (dynamic_entries * dynamic_entry_size) as u64;
put_segment(
&mut bytes,
second,
2,
dynamic_offset,
dynamic_offset,
self.dynamic_filesz.unwrap_or(dynamic_size),
);
let dynamic_base = dynamic_offset as usize;
let put_dynamic = |bytes: &mut Vec<u8>, index: usize, tag: u64, value: u64| {
let at = dynamic_base + index * dynamic_entry_size;
if self.class64 {
self.put_u64(bytes, at, tag);
self.put_u64(bytes, at + 8, value);
} else {
self.put_u32(bytes, at, tag as u32);
self.put_u32(bytes, at + 4, value as u32);
}
};
put_dynamic(&mut bytes, 0, DT_STRTAB, strtab_offset);
if self.versions.is_empty() {
put_dynamic(&mut bytes, 1, DT_NULL, 0);
} else {
put_dynamic(&mut bytes, 1, DT_VERNEED, verneed_offset);
put_dynamic(&mut bytes, 2, DT_VERNEEDNUM, 1);
put_dynamic(&mut bytes, 3, DT_NULL, 0);
}
if !self.versions.is_empty() {
let base = verneed_offset as usize;
self.put_u16(&mut bytes, base, 1); self.put_u16(&mut bytes, base + 2, self.versions.len() as u16); self.put_u32(&mut bytes, base + 4, 0); self.put_u32(&mut bytes, base + 8, 16); self.put_u32(&mut bytes, base + 12, 0); for (index, name_offset) in name_offsets.iter().enumerate() {
let at = base + 16 + index * 16;
self.put_u32(&mut bytes, at, 0); self.put_u16(&mut bytes, at + 4, 0); self.put_u16(&mut bytes, at + 6, (index + 1) as u16); self.put_u32(&mut bytes, at + 8, *name_offset); self.put_u32(
&mut bytes,
at + 12,
if index + 1 < self.versions.len() {
16
} else {
0
},
); }
}
bytes
}
}
}
#[cfg(test)]
mod tests {
use super::test_support::ElfBuilder;
use super::*;
use crate::{
BuildStrategy, CompatibilityFloor, HostArch, HostOs, Qualification, SupportTier,
TargetPolicy, ToolchainRequirement,
};
fn policy(floor: CompatibilityFloor, strategy: BuildStrategy) -> TargetPolicy {
TargetPolicy {
target: "x86_64-unknown-linux-gnu".into(),
strategy,
host_os: HostOs::Linux,
host_arch: HostArch::X86_64,
qualification_host: None,
toolchain: ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: None,
zig: None,
},
floor,
qualification: Qualification::Native,
support: SupportTier::Required,
}
}
fn glibc(major: u16, minor: u16) -> CompatibilityFloor {
CompatibilityFloor::Glibc { major, minor }
}
fn write(bytes: &[u8]) -> std::path::PathBuf {
let root = crate::test_temp_dir("floor");
let path = root.join("candidate");
std::fs::write(&path, bytes).unwrap();
path
}
fn status_for(bytes: &[u8], floor: CompatibilityFloor) -> FloorVerificationStatus {
let path = write(bytes);
let status = inspect_candidate_floor(&path, &floor, BuildStrategy::NativeCargo);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
status
}
#[test]
fn reader_reports_the_highest_required_glibc_version() {
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17", "GLIBC_2.34", "GLIBC_2.2.5"])
.build();
let path = write(&image);
let required = read_glibc_requirement(&path).unwrap();
assert_eq!(
required.highest,
Some(GlibcVersion {
major: 2,
minor: 34,
patch: 0
})
);
assert!(!required.unrecognized);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
}
#[test]
fn reader_reports_no_requirement_when_the_image_has_none() {
let image = ElfBuilder::new(true, true).build();
let path = write(&image);
let required = read_glibc_requirement(&path).unwrap();
assert_eq!(required.highest, None);
assert!(!required.unrecognized);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
let image = ElfBuilder::new(true, true)
.versions(&["CXXABI_1.3"])
.build();
let path = write(&image);
let required = read_glibc_requirement(&path).unwrap();
assert_eq!(required.highest, None);
assert!(!required.unrecognized);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
}
#[test]
fn reader_reads_32_bit_and_big_endian_images() {
let image = ElfBuilder::new(false, true)
.versions(&["GLIBC_2.17"])
.build();
let path = write(&image);
assert_eq!(
read_glibc_requirement(&path).unwrap().highest,
Some(GlibcVersion {
major: 2,
minor: 17,
patch: 0
})
);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
let image = ElfBuilder::new(true, false)
.versions(&["GLIBC_2.17"])
.build();
let path = write(&image);
assert_eq!(
read_glibc_requirement(&path).unwrap().highest,
Some(GlibcVersion {
major: 2,
minor: 17,
patch: 0
})
);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
}
#[test]
fn reader_refuses_truncated_malformed_and_non_elf_inputs() {
let path = write(b"this is not an elf image");
assert_eq!(read_glibc_requirement(&path), Err(FloorReadError::NotAnElf));
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17"])
.build();
let path = write(&image[..image.len() - 8]);
assert!(read_glibc_requirement(&path).is_err());
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17"])
.build();
let path = write(&image[..80]);
assert!(read_glibc_requirement(&path).is_err());
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17"])
.program_header_offset(1 << 30)
.build();
let path = write(&image);
assert!(read_glibc_requirement(&path).is_err());
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
}
#[test]
fn reader_refuses_oversized_tables_instead_of_parsing_them() {
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17"])
.program_header_count(4096)
.build();
let path = write(&image);
assert_eq!(
read_glibc_requirement(&path),
Err(FloorReadError::BoundExceeded)
);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17"])
.dynamic_filesz(1 << 20)
.build();
let path = write(&image);
assert_eq!(
read_glibc_requirement(&path),
Err(FloorReadError::BoundExceeded)
);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
}
#[test]
fn comparison_direction_requires_the_newest_version_to_fit_under_the_floor() {
let newer = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.34"])
.build();
let equal = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17"])
.build();
let older = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.2.5"])
.build();
assert_eq!(
status_for(&newer, glibc(2, 17)),
FloorVerificationStatus::NotSatisfied
);
assert_eq!(
status_for(&equal, glibc(2, 17)),
FloorVerificationStatus::Verified
);
assert_eq!(
status_for(&older, glibc(2, 17)),
FloorVerificationStatus::Verified
);
assert_eq!(
status_for(&older, glibc(2, 34)),
FloorVerificationStatus::Verified
);
assert_eq!(
status_for(&older, glibc(2, 2)),
FloorVerificationStatus::NotSatisfied
);
}
#[test]
fn an_image_without_a_version_requirement_is_recorded_specifically() {
let image = ElfBuilder::new(true, true).build();
assert_eq!(
status_for(&image, glibc(2, 17)),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::NoVersionRequirement)
);
}
#[test]
fn a_malformed_candidate_is_never_verified() {
assert_eq!(
status_for(b"not an elf", glibc(2, 17)),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::UnreadableCandidate)
);
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.17"])
.build();
assert_eq!(
status_for(&image[..image.len() - 8], glibc(2, 17)),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::MalformedCandidate)
);
}
#[test]
fn an_unrecognized_version_name_is_never_verified() {
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_ABI_DT_RELR"])
.build();
assert_eq!(
status_for(&image, glibc(2, 17)),
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::UnrecognizedVersionRequirement
)
);
}
#[test]
fn an_unrecognized_version_name_does_not_mask_a_contradicted_floor() {
for extra in ["GLIBC_PRIVATE", "GLIBC_ABI_DT_RELR"] {
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_2.34", extra])
.build();
assert_eq!(
status_for(&image, glibc(2, 17)),
FloorVerificationStatus::NotSatisfied,
"{extra} must not mask the contradicted floor"
);
assert_eq!(
status_for(&image, glibc(2, 34)),
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::UnrecognizedVersionRequirement
)
);
}
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_PRIVATE"])
.build();
assert_eq!(
status_for(&image, glibc(2, 17)),
FloorVerificationStatus::Unverified(
FloorUnverifiedReason::UnrecognizedVersionRequirement
)
);
}
#[test]
fn an_unrecognized_version_name_does_not_hide_a_numeric_requirement() {
let image = ElfBuilder::new(true, true)
.versions(&["GLIBC_PRIVATE", "GLIBC_2.34"])
.build();
let path = write(&image);
let required = read_glibc_requirement(&path).unwrap();
assert_eq!(
required.highest,
Some(GlibcVersion {
major: 2,
minor: 34,
patch: 0
})
);
assert!(required.unrecognized);
std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
}
#[test]
fn a_virtual_address_translation_cannot_overflow() {
let segments = vec![ProgramSegment {
kind: PT_LOAD,
offset: u64::MAX - 10,
vaddr: 0,
filesz: 1024,
}];
assert_eq!(map_vaddr(&segments, 20), Err(FloorReadError::Malformed));
}
#[test]
fn the_plan_status_is_derived_from_the_policy() {
assert_eq!(
planned_floor_status(&policy(
CompatibilityFloor::None,
BuildStrategy::NativeCargo
)),
FloorVerificationStatus::NotDeclared
);
assert_eq!(
planned_floor_status(&policy(glibc(2, 17), BuildStrategy::CargoZigbuild)),
FloorVerificationStatus::ToolchainBound
);
assert_eq!(
planned_floor_status(&policy(glibc(2, 17), BuildStrategy::NativeCargo)),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::PendingInspection)
);
assert_eq!(
planned_floor_status(&policy(
CompatibilityFloor::Macos {
major: 13,
minor: 0
},
BuildStrategy::NativeCargo
)),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::FloorKindNotVerifiable)
);
}
#[test]
fn admissible_statuses_are_closed_per_declaration() {
assert!(floor_status_admissible(
&CompatibilityFloor::None,
BuildStrategy::NativeCargo,
FloorVerificationStatus::NotDeclared
));
assert!(!floor_status_admissible(
&CompatibilityFloor::None,
BuildStrategy::NativeCargo,
FloorVerificationStatus::Verified
));
assert!(floor_status_admissible(
&glibc(2, 17),
BuildStrategy::CargoZigbuild,
FloorVerificationStatus::ToolchainBound
));
assert!(!floor_status_admissible(
&glibc(2, 17),
BuildStrategy::CargoZigbuild,
FloorVerificationStatus::Verified
));
assert!(floor_status_admissible(
&glibc(2, 17),
BuildStrategy::NativeCargo,
FloorVerificationStatus::Verified
));
assert!(floor_status_admissible(
&glibc(2, 17),
BuildStrategy::NativeCargo,
FloorVerificationStatus::NotSatisfied
));
assert!(!floor_status_admissible(
&glibc(2, 17),
BuildStrategy::NativeCargo,
FloorVerificationStatus::ToolchainBound
));
}
#[test]
fn combined_statuses_keep_the_most_severe_result() {
assert_eq!(
aggregate_floor_status(&[
FloorVerificationStatus::Verified,
FloorVerificationStatus::NotSatisfied
]),
FloorVerificationStatus::NotSatisfied
);
assert_eq!(
aggregate_floor_status(&[
FloorVerificationStatus::Verified,
FloorVerificationStatus::Unverified(FloorUnverifiedReason::NoVersionRequirement)
]),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::NoVersionRequirement)
);
assert_eq!(
aggregate_floor_status(&[
FloorVerificationStatus::Unverified(FloorUnverifiedReason::NoVersionRequirement),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::UnreadableCandidate)
]),
FloorVerificationStatus::Unverified(FloorUnverifiedReason::UnreadableCandidate)
);
assert_eq!(
aggregate_floor_status(&[FloorVerificationStatus::Verified]),
FloorVerificationStatus::Verified
);
}
}