use std::fmt;
pub const SIGNATURE: &[u8; 4] = b"PReg";
pub const VERSION: u32 = 1;
#[derive(Debug, thiserror::Error, PartialEq, Eq)]
pub enum PolError {
#[error("not a Registry.pol file: bad PReg signature")]
BadSignature,
#[error("unsupported PReg version {0}")]
BadVersion(u32),
#[error("truncated at offset {0}")]
Truncated(usize),
#[error("expected {expected:?} at offset {at}")]
Expected { expected: char, at: usize },
#[error("unterminated UTF-16 string at offset {0}")]
UnterminatedString(usize),
#[error("value data at offset {at} claims {len} bytes, {left} left in file")]
BadDataLength { at: usize, len: usize, left: usize },
}
type Result<T> = std::result::Result<T, PolError>;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RegData {
Sz(String),
ExpandSz(String),
Binary(Vec<u8>),
Dword(u32),
DwordBe(u32),
Link(String),
MultiSz(Vec<String>),
Qword(u64),
Other { ty: u32, bytes: Vec<u8> },
}
impl RegData {
pub fn type_code(&self) -> u32 {
match self {
RegData::Sz(_) => 1,
RegData::ExpandSz(_) => 2,
RegData::Binary(_) => 3,
RegData::Dword(_) => 4,
RegData::DwordBe(_) => 5,
RegData::Link(_) => 6,
RegData::MultiSz(_) => 7,
RegData::Qword(_) => 11,
RegData::Other { ty, .. } => *ty,
}
}
pub fn to_bytes(&self) -> Vec<u8> {
match self {
RegData::Sz(s) | RegData::ExpandSz(s) | RegData::Link(s) => utf16z(s),
RegData::Binary(b) => b.clone(),
RegData::Dword(v) => v.to_le_bytes().to_vec(),
RegData::DwordBe(v) => v.to_be_bytes().to_vec(),
RegData::Qword(v) => v.to_le_bytes().to_vec(),
RegData::MultiSz(items) => {
let mut out = Vec::new();
for s in items {
out.extend_from_slice(&utf16z(s));
}
out.extend_from_slice(&[0, 0]); out
}
RegData::Other { bytes, .. } => bytes.clone(),
}
}
fn from_raw(ty: u32, bytes: &[u8]) -> RegData {
match ty {
1 => RegData::Sz(utf16_lossy(bytes)),
2 => RegData::ExpandSz(utf16_lossy(bytes)),
3 => RegData::Binary(bytes.to_vec()),
4 if bytes.len() >= 4 => {
RegData::Dword(u32::from_le_bytes(bytes[..4].try_into().unwrap()))
}
5 if bytes.len() >= 4 => {
RegData::DwordBe(u32::from_be_bytes(bytes[..4].try_into().unwrap()))
}
6 => RegData::Link(utf16_lossy(bytes)),
7 => RegData::MultiSz(
utf16_lossy(bytes)
.split('\0')
.filter(|s| !s.is_empty())
.map(str::to_string)
.collect(),
),
11 if bytes.len() >= 8 => {
RegData::Qword(u64::from_le_bytes(bytes[..8].try_into().unwrap()))
}
_ => RegData::Other {
ty,
bytes: bytes.to_vec(),
},
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Directive<'a> {
Set,
DeleteValue(&'a str),
DeleteAllValues,
DeleteKeys,
Soft(&'a str),
SecureKey,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PolicyEntry {
pub key: String,
pub value: String,
pub data: RegData,
}
impl PolicyEntry {
pub fn new(key: impl Into<String>, value: impl Into<String>, data: RegData) -> Self {
PolicyEntry {
key: key.into(),
value: value.into(),
data,
}
}
pub fn directive(&self) -> Directive<'_> {
let v = self.value.as_str();
if let Some(rest) = strip_prefix_ci(v, "**del.") {
return Directive::DeleteValue(rest);
}
if let Some(rest) = strip_prefix_ci(v, "**soft.") {
return Directive::Soft(rest);
}
if strip_prefix_ci(v, "**delvals").is_some() {
return Directive::DeleteAllValues;
}
if strip_prefix_ci(v, "**deletekeys").is_some() {
return Directive::DeleteKeys;
}
if strip_prefix_ci(v, "**securekey").is_some() {
return Directive::SecureKey;
}
Directive::Set
}
}
impl fmt::Display for PolicyEntry {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}\\{} = {:?}", self.key, self.value, self.data)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PolicyFile {
pub entries: Vec<PolicyEntry>,
}
impl PolicyFile {
pub fn new() -> Self {
PolicyFile::default()
}
pub fn parse(b: &[u8]) -> Result<PolicyFile> {
if b.len() < 8 {
return Err(PolError::Truncated(0));
}
if &b[..4] != SIGNATURE {
return Err(PolError::BadSignature);
}
let version = u32::from_le_bytes(b[4..8].try_into().unwrap());
if version != VERSION {
return Err(PolError::BadVersion(version));
}
let mut entries = Vec::new();
let mut cur = 8;
while cur < b.len() {
if b.len() - cur < 2 {
break;
}
expect_char(b, &mut cur, '[')?;
let key = read_utf16z(b, &mut cur)?;
expect_char(b, &mut cur, ';')?;
let value = read_utf16z(b, &mut cur)?;
expect_char(b, &mut cur, ';')?;
let ty = read_u32(b, &mut cur)?;
expect_char(b, &mut cur, ';')?;
let size = read_u32(b, &mut cur)? as usize;
expect_char(b, &mut cur, ';')?;
let left = b.len().saturating_sub(cur);
if size > left {
return Err(PolError::BadDataLength {
at: cur,
len: size,
left,
});
}
let data = RegData::from_raw(ty, &b[cur..cur + size]);
cur += size;
expect_char(b, &mut cur, ']')?;
entries.push(PolicyEntry { key, value, data });
}
Ok(PolicyFile { entries })
}
pub fn to_bytes(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(8 + self.entries.len() * 64);
out.extend_from_slice(SIGNATURE);
out.extend_from_slice(&VERSION.to_le_bytes());
for e in &self.entries {
let data = e.data.to_bytes();
push_char(&mut out, '[');
out.extend_from_slice(&utf16z(&e.key));
push_char(&mut out, ';');
out.extend_from_slice(&utf16z(&e.value));
push_char(&mut out, ';');
out.extend_from_slice(&e.data.type_code().to_le_bytes());
push_char(&mut out, ';');
out.extend_from_slice(&(data.len() as u32).to_le_bytes());
push_char(&mut out, ';');
out.extend_from_slice(&data);
push_char(&mut out, ']');
}
out
}
pub fn get(&self, key: &str, value: &str) -> Option<&PolicyEntry> {
self.entries
.iter()
.find(|e| e.key.eq_ignore_ascii_case(key) && e.value.eq_ignore_ascii_case(value))
}
pub fn dword(&self, key: &str, value: &str) -> Option<u32> {
match self.get(key, value)?.data {
RegData::Dword(v) => Some(v),
RegData::DwordBe(v) => Some(v),
_ => None,
}
}
pub fn under<'a>(&'a self, key: &'a str) -> impl Iterator<Item = &'a PolicyEntry> + 'a {
self.entries
.iter()
.filter(move |e| e.key.eq_ignore_ascii_case(key))
}
pub fn set(&mut self, key: &str, value: &str, data: RegData) {
match self
.entries
.iter_mut()
.find(|e| e.key.eq_ignore_ascii_case(key) && e.value.eq_ignore_ascii_case(value))
{
Some(e) => e.data = data,
None => self.entries.push(PolicyEntry::new(key, value, data)),
}
}
pub fn remove(&mut self, key: &str, value: &str) -> usize {
let before = self.entries.len();
self.entries
.retain(|e| !(e.key.eq_ignore_ascii_case(key) && e.value.eq_ignore_ascii_case(value)));
before - self.entries.len()
}
}
fn utf16z(s: &str) -> Vec<u8> {
let mut out: Vec<u8> = s.encode_utf16().flat_map(u16::to_le_bytes).collect();
out.extend_from_slice(&[0, 0]);
out
}
fn utf16_lossy(b: &[u8]) -> String {
let units: Vec<u16> = b
.chunks_exact(2)
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect();
let trimmed = match units.iter().rposition(|&u| u != 0) {
Some(i) => &units[..=i],
None => &[][..],
};
String::from_utf16_lossy(trimmed)
}
fn push_char(out: &mut Vec<u8>, c: char) {
out.extend_from_slice(&(c as u16).to_le_bytes());
}
fn expect_char(b: &[u8], cur: &mut usize, c: char) -> Result<()> {
let got = b
.get(*cur..*cur + 2)
.ok_or(PolError::Truncated(*cur))
.map(|s| u16::from_le_bytes([s[0], s[1]]))?;
if got != c as u16 {
return Err(PolError::Expected {
expected: c,
at: *cur,
});
}
*cur += 2;
Ok(())
}
fn read_utf16z(b: &[u8], cur: &mut usize) -> Result<String> {
let start = *cur;
let mut units = Vec::new();
loop {
let s = b
.get(*cur..*cur + 2)
.ok_or(PolError::UnterminatedString(start))?;
let u = u16::from_le_bytes([s[0], s[1]]);
*cur += 2;
if u == 0 {
return Ok(String::from_utf16_lossy(&units));
}
units.push(u);
}
}
fn read_u32(b: &[u8], cur: &mut usize) -> Result<u32> {
let s = b.get(*cur..*cur + 4).ok_or(PolError::Truncated(*cur))?;
*cur += 4;
Ok(u32::from_le_bytes(s.try_into().unwrap()))
}
fn strip_prefix_ci<'a>(s: &'a str, prefix: &str) -> Option<&'a str> {
(s.len() >= prefix.len() && s[..prefix.len()].eq_ignore_ascii_case(prefix))
.then(|| &s[prefix.len()..])
}