diff --git a/sw/host/opentitanlib/src/lib.rs b/sw/host/opentitanlib/src/lib.rs
index 38e9c55..71ddeab 100644
--- a/sw/host/opentitanlib/src/lib.rs
+++ b/sw/host/opentitanlib/src/lib.rs
@@ -5,6 +5,7 @@
 pub mod app;
 pub mod bootstrap;
 pub mod io;
+pub mod otp;
 pub mod spiflash;
 pub mod transport;
 pub mod util;
diff --git a/sw/host/opentitanlib/src/otp/lc_state.rs b/sw/host/opentitanlib/src/otp/lc_state.rs
new file mode 100644
index 0000000..813d8da
--- /dev/null
+++ b/sw/host/opentitanlib/src/otp/lc_state.rs
@@ -0,0 +1,110 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::{bail, Result};
+use serde::Deserialize;
+use std::fs;
+use std::path::Path;
+
+/// SECDED matrix used for ECC in OTP.
+#[derive(Deserialize, Debug)]
+pub struct LcSecded {
+    /// The number of bits of data covered by ECC.
+    data_width: usize,
+    /// The number of ECC bits.
+    ecc_width: usize,
+    /// ECC matrix used for computing ECC bits.
+    ecc_matrix: Vec<Vec<u8>>,
+}
+
+/// The internal representation of lc_ctrl_state, used in OTP operations.
+#[derive(Deserialize, Debug)]
+pub struct LcState {
+    secded: LcSecded,
+}
+
+impl LcSecded {
+    pub fn new(in_file: &Path) -> Result<LcSecded> {
+        let json_text = fs::read_to_string(in_file)?;
+        let res: LcState = deser_hjson::from_str(&json_text)?;
+        if res.secded.ecc_matrix.len() != res.secded.ecc_width {
+            bail!("Bad ecc matrix length {}", res.secded.ecc_matrix.len());
+        }
+        Ok(res.secded)
+    }
+
+    fn bit_index(data: &[u8], index: usize) -> bool {
+        let byte = index / 8;
+        let bit = index % 8;
+        data[byte] & (1 << bit) != 0
+    }
+
+    pub fn ecc_encode(&self, mut data: Vec<u8>) -> Result<Vec<u8>> {
+        if data.len() * 8 != self.data_width {
+            bail!("Bad data length for ecc {}", data.len() * 8);
+        }
+        let data_len = data.len();
+        data.resize(data_len + self.ecc_byte_len(), 0);
+        for (i, matrix) in self.ecc_matrix.iter().enumerate() {
+            let mut bit = false;
+            for j in matrix {
+                bit ^= Self::bit_index(&data, *j as usize);
+            }
+            if bit {
+                let byte = i / 8 + data_len;
+                let bit = i % 8;
+                data[byte] |= 1 << bit;
+            }
+        }
+
+        Ok(data)
+    }
+
+    pub fn ecc_byte_len(&self) -> usize {
+        if self.ecc_width == 0 {
+            0
+        } else {
+            (self.ecc_width - 1) / 8 + 1
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::Result;
+    use deser_hjson::from_str;
+    use std::fs::read_to_string;
+
+    #[test]
+    fn test_lc_state_deserialize() -> Result<()> {
+        let _: LcState = from_str(&read_to_string("tests/lc_ctrl_state.hjson")?)?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_ecc_encode() {
+        let secded = LcSecded {
+            data_width: 16,
+            ecc_width: 6,
+            ecc_matrix: vec![
+                vec![0, 1, 3, 4, 6, 8, 10, 11, 13, 15], // ECC bit 0
+                vec![0, 2, 3, 5, 6, 9, 10, 12, 13],     // ECC bit 1
+                vec![1, 2, 3, 7, 8, 9, 10, 14, 15],     // ECC bit 2
+                vec![4, 5, 6, 7, 8, 9, 10],             // ECC bit 3
+                vec![11, 12, 13, 14, 15],               // ECC bit 4
+                vec![
+                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+                ], // Parity bit
+            ],
+        };
+
+        let zero: Vec<u8> = vec![0, 0];
+        let a5a5: Vec<u8> = vec![0xa5, 0xa5];
+        let fcc5: Vec<u8> = vec![0xfc, 0xc5];
+        assert_eq!(vec![0u8, 0, 0], secded.ecc_encode(zero).unwrap());
+        assert_eq!(vec![0xa5u8, 0xa5, 0x27], secded.ecc_encode(a5a5).unwrap());
+        assert_eq!(vec![0x0fcu8, 0xc5, 0x06], secded.ecc_encode(fcc5).unwrap())
+    }
+}
diff --git a/sw/host/opentitanlib/src/otp/mod.rs b/sw/host/opentitanlib/src/otp/mod.rs
new file mode 100644
index 0000000..8465483
--- /dev/null
+++ b/sw/host/opentitanlib/src/otp/mod.rs
@@ -0,0 +1,37 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod lc_state;
+pub mod otp;
+pub mod otp_img;
+pub mod otp_mmap;
+pub mod vmem_serialize;
+
+mod num_de;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::Result;
+    use std::path::Path;
+
+    #[test]
+    fn test_vmem_serialize() -> Result<()> {
+        let mut otp_mmap = otp_mmap::OtpMap::new(Path::new("tests/otp_ctrl_mmap.hjson"))?;
+        let mut otp_img = otp_img::OtpImg::new(Path::new("tests/otp_ctrl_img_dev.hjson"))?;
+        let lc_state = lc_state::LcSecded::new(Path::new("tests/lc_ctrl_state.hjson"))?;
+        let vmem = otp_mmap.make_vmem(&mut otp_img)?;
+        let keys = otp_mmap.generate_keys(&otp_img);
+        let result = vmem.generate(keys, &lc_state)?;
+        let expected = std::fs::read_to_string(Path::new("tests/output.vmem"))?;
+        let expected = expected
+            .split("\n")
+            .filter(|s| !s.is_empty())
+            .collect::<Vec<&str>>();
+
+        assert_eq!(result, expected);
+
+        Ok(())
+    }
+}
diff --git a/sw/host/opentitanlib/src/otp/num_de.rs b/sw/host/opentitanlib/src/otp/num_de.rs
new file mode 100644
index 0000000..d621e9e
--- /dev/null
+++ b/sw/host/opentitanlib/src/otp/num_de.rs
@@ -0,0 +1,228 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+/// Deserialization utilities for certain values in OTP HJSON files.
+///
+/// The OTP HJSON files have some strange values:
+///
+/// Integers, sometimes wrapped in strings, with inconsistent formatting and meta values, such as:
+///   - value: "0x739"
+///   - key_size: "16"
+///   - seed: "10556718629619452145"
+///   - seed: 01931961561863975174  // This is a decimal integer, not octal.
+///   - value: "<random>"
+///
+/// Additionally, some values have sizes defined within the config files themselves, such as the
+/// keys. This module exists to handle these peculiar cases.
+use anyhow::Result;
+use rand::RngCore;
+use serde::de::{self, Deserializer, Unexpected};
+use serde::ser::Serializer;
+use serde::{Deserialize, Serialize};
+use std::any::type_name;
+use std::fmt;
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+use crate::util::parse_int::{ParseInt, ParseIntError};
+
+pub fn _serialize<S, T>(_r: T, _ser: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: Serialize + Copy,
+{
+    unimplemented!();
+}
+
+/// Deserialize numeric types from HJSON config files.
+pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+where
+    D: Deserializer<'de>,
+    T: ParseInt,
+{
+    struct Visitor<U>(PhantomData<U>);
+
+    impl<'a, U: ParseInt> de::Visitor<'a> for Visitor<U> {
+        type Value = U;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_fmt(format_args!("a string that parses to {}", type_name::<U>()))
+        }
+
+        fn visit_string<E>(self, mut name: String) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            if name.starts_with("false") {
+                name = "0".to_owned()
+            } else if name.starts_with("true") {
+                name = "1".to_owned()
+            }
+
+            let trimmed = if name.starts_with("0x") {
+                &name
+            } else {
+                let trimmed = name[0..name.len() - 1].trim_start_matches('0');
+                &name[name.len() - trimmed.len() - 1..]
+            };
+
+            match U::from_str(trimmed) {
+                Ok(value) => Ok(value),
+                Err(_) => Err(de::Error::invalid_value(Unexpected::Str(trimmed), &self)),
+            }
+        }
+
+        fn visit_str<E>(self, name: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            self.visit_string(name.to_owned())
+        }
+
+        fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            if v {
+                self.visit_str("1")
+            } else {
+                self.visit_str("0")
+            }
+        }
+    }
+
+    deserializer.deserialize_string(Visitor {
+        0: PhantomData::<T>,
+    })
+}
+
+/// Placeholder type for values that cannot be resolved during deserialization.
+#[derive(Debug, PartialEq, Clone)]
+enum DeferredInit {
+    Initialized(Vec<u8>),
+    Random,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct DeferredValue(#[serde(with = "self")] DeferredInit);
+
+impl DeferredValue {
+    pub fn resolve(&self, size: usize, rng: &mut dyn RngCore) -> Vec<u8> {
+        match self.0.clone() {
+            DeferredInit::Initialized(mut vec) => {
+                vec.resize(size, 0);
+                vec
+            }
+            DeferredInit::Random => {
+                let mut vec = vec![0u8; size];
+                rng.fill_bytes(&mut vec);
+                vec
+            }
+        }
+    }
+
+    pub fn is_initialized(&self) -> bool {
+        matches!(self.0, DeferredInit::Initialized(_))
+    }
+}
+
+impl ParseInt for DeferredInit {
+    type FromStrRadixErr = ParseIntError;
+
+    fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
+        Ok(DeferredInit::Initialized(Vec::<u8>::from_str_radix(
+            src, radix,
+        )?))
+    }
+
+    fn from_str(src: &str) -> Result<Self, ParseIntError> {
+        if src == "<random>" {
+            Ok(DeferredInit::Random)
+        } else {
+            Ok(DeferredInit::Initialized(Vec::<u8>::from_str(src)?))
+        }
+    }
+}
+
+impl Deref for DeferredValue {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        match &self.0 {
+            DeferredInit::Initialized(val) => val,
+            _ => panic!("Value has not been initialized"),
+        }
+    }
+}
+
+/// Wrapper type to force deserialization assuming octal encoding.
+#[derive(Deserialize, Debug)]
+pub struct OctEncoded<T: ParseInt>(#[serde(with = "self")] T);
+
+/// Wrapper type to force deserialization assuming decimal encoding.
+#[derive(Deserialize, Debug)]
+pub struct DecEncoded<T: ParseInt>(#[serde(with = "self")] T);
+
+/// Wrapper type to force deserialization assuming hexadecimal encoding.
+#[derive(Deserialize, Debug)]
+pub struct HexEncoded<T: ParseInt>(#[serde(with = "self")] T);
+
+macro_rules! impl_parse_int_enc {
+    ($ty:ident, $radix:expr) => {
+        impl<T: ParseInt> std::ops::Deref for $ty<T> {
+            type Target = T;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl<T: ParseInt> ParseInt for $ty<T> {
+            type FromStrRadixErr = T::FromStrRadixErr;
+
+            fn from_str_radix(src: &str, radix: u32) -> Result<Self, T::FromStrRadixErr> {
+                Ok(Self(T::from_str_radix(src, radix)?))
+            }
+
+            fn from_str(src: &str) -> Result<Self, ParseIntError> {
+                Self::from_str_radix(src, $radix).map_err(|e| e.into())
+            }
+        }
+    };
+}
+
+impl_parse_int_enc!(OctEncoded, 8);
+impl_parse_int_enc!(DecEncoded, 10);
+impl_parse_int_enc!(HexEncoded, 16);
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use serde::Deserialize;
+
+    #[test]
+    fn de_u8() -> Result<()> {
+        #[derive(Debug, Deserialize)]
+        struct TestData {
+            #[serde(with = "super")]
+            oct: OctEncoded<u8>,
+            #[serde(with = "super")]
+            dec: DecEncoded<u8>,
+            #[serde(with = "super")]
+            hex: HexEncoded<u8>,
+        }
+
+        let data: TestData = deser_hjson::from_str(stringify!(
+        {
+            oct: "77",
+            dec: "77",
+            hex: "77"
+        }))?;
+
+        assert_eq!(*data.oct, 63);
+        assert_eq!(*data.dec, 77);
+        assert_eq!(*data.hex, 119);
+        Ok(())
+    }
+}
diff --git a/sw/host/opentitanlib/src/otp/otp.rs b/sw/host/opentitanlib/src/otp/otp.rs
new file mode 100644
index 0000000..c11fea0
--- /dev/null
+++ b/sw/host/opentitanlib/src/otp/otp.rs
@@ -0,0 +1,44 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::util::parse_int::{ParseInt, ParseIntError};
+
+use anyhow::Result;
+
+impl ParseInt for Vec<u8> {
+    type FromStrRadixErr = ParseIntError;
+
+    fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
+        let mut bytes = vec![];
+        for digit_bytes in src.as_bytes().rchunks(2) {
+            let digits = std::str::from_utf8(digit_bytes).unwrap();
+            bytes.push(u8::from_str_radix(digits, radix)?);
+        }
+        Ok(bytes)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::convert::TryInto;
+    #[test]
+    fn byte_field_test() {
+        assert_eq!(Vec::from_str("0x1"), Ok(vec![0x1]));
+        assert_eq!(
+            Vec::from_str("0x4b4b4b4b4b4ba5a5"),
+            Ok(vec![0xa5, 0xa5, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b])
+        );
+        assert_eq!(
+            u64::from_ne_bytes(
+                Vec::from_str("0x4b4b4b4b4b4ba5a5")
+                    .unwrap()
+                    .try_into()
+                    .unwrap()
+            ),
+            u64::from_str("0x4b4b4b4b4b4ba5a5").unwrap()
+        );
+        assert!(Vec::from_str("-1").is_err());
+    }
+}
diff --git a/sw/host/opentitanlib/src/otp/otp_img.rs b/sw/host/opentitanlib/src/otp/otp_img.rs
new file mode 100644
index 0000000..fe05775
--- /dev/null
+++ b/sw/host/opentitanlib/src/otp/otp_img.rs
@@ -0,0 +1,60 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use serde::Deserialize;
+
+use std::path::Path;
+
+use crate::otp::num_de::{DecEncoded, DeferredValue};
+use anyhow::Result;
+use rand::rngs::StdRng;
+use rand::SeedableRng;
+
+const OTP_IMG_SEED_DIVERSIFIER: u64 = 1941661965323525198146u128 as u64;
+
+#[derive(Deserialize, Debug)]
+pub struct OtpImgItem {
+    pub name: String,
+    pub value: DeferredValue,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct OtpImgPartition {
+    pub name: String,
+    pub items: Option<Vec<OtpImgItem>>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct OtpImg {
+    pub seed: DecEncoded<u64>,
+    pub partitions: Vec<OtpImgPartition>,
+}
+
+impl OtpImgPartition {
+    pub fn get_item(&mut self, name: &str) -> Option<&mut OtpImgItem> {
+        self.items
+            .as_mut()
+            .and_then(|items| items.iter_mut().find(|i| i.name == name))
+    }
+}
+
+impl OtpImg {
+    pub fn new(in_file: &Path) -> Result<OtpImg> {
+        let json_text = std::fs::read_to_string(in_file)?;
+        let res: OtpImg = deser_hjson::from_str(&json_text)?;
+        Ok(res)
+    }
+
+    pub fn get_partition(&mut self, name: &str) -> Option<&mut OtpImgPartition> {
+        self.partitions.iter_mut().find(|p| p.name == name)
+    }
+
+    pub fn partition(&self) -> &[OtpImgPartition] {
+        &self.partitions
+    }
+
+    pub fn get_rng(&self) -> StdRng {
+        StdRng::seed_from_u64(OTP_IMG_SEED_DIVERSIFIER + *self.seed)
+    }
+}
diff --git a/sw/host/opentitanlib/src/otp/otp_mmap.rs b/sw/host/opentitanlib/src/otp/otp_mmap.rs
new file mode 100644
index 0000000..e6960c3
--- /dev/null
+++ b/sw/host/opentitanlib/src/otp/otp_mmap.rs
@@ -0,0 +1,207 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::otp::num_de::{self, DeferredValue};
+use crate::otp::otp_img::OtpImg;
+use crate::otp::vmem_serialize::*;
+
+use anyhow::{anyhow, bail, Result};
+use serde::Deserialize;
+use std::collections::HashMap;
+use std::convert::TryInto;
+use std::fs;
+use std::path::Path;
+
+#[derive(Deserialize, Debug)]
+struct OtpMapConfig {
+    #[serde(with = "num_de")]
+    width: usize,
+    #[serde(with = "num_de")]
+    depth: usize,
+}
+
+#[derive(Deserialize, Debug)]
+struct OtpMapKey {
+    name: String,
+    value: DeferredValue,
+}
+
+#[derive(Deserialize, Debug)]
+struct OtpMapDigest {
+    name: String,
+    iv_value: DeferredValue,
+    cnst_value: DeferredValue,
+}
+
+#[derive(Deserialize, Debug)]
+struct OtpMapScrambling {
+    #[serde(with = "num_de")]
+    key_size: usize,
+    #[serde(with = "num_de")]
+    iv_size: usize,
+    #[serde(with = "num_de")]
+    cnst_size: usize,
+    keys: Vec<OtpMapKey>,
+    digests: Vec<OtpMapDigest>,
+}
+
+#[derive(Deserialize, Debug)]
+struct OtpMapItem {
+    name: String,
+    #[serde(with = "num_de")]
+    size: usize,
+    #[serde(default)]
+    isdigest: bool,
+    inv_default: Option<DeferredValue>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct OtpMapPartition {
+    name: String,
+    secret: bool,
+    #[serde(default, with = "num_de")]
+    size: usize,
+    sw_digest: bool,
+    hw_digest: bool,
+    key_sel: String,
+    items: Vec<OtpMapItem>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct OtpMap {
+    seed: String,
+    otp: OtpMapConfig,
+    scrambling: OtpMapScrambling,
+    partitions: Vec<OtpMapPartition>,
+}
+
+impl OtpMap {
+    pub fn new(in_file: &Path) -> Result<OtpMap> {
+        let json_text = fs::read_to_string(in_file)?;
+        let res: OtpMap = deser_hjson::from_str(&json_text)?;
+        Ok(res)
+    }
+
+    pub fn generate_keys(&self, img: &OtpImg) -> HashMap<String, Vec<u8>> {
+        let mut rng = img.get_rng();
+        let mut map = HashMap::new();
+        for key in &self.scrambling.keys {
+            let value = key.value.resolve(self.scrambling.key_size, &mut rng);
+            map.insert(key.name.clone(), value);
+        }
+        map
+    }
+
+    pub fn make_vmem(&mut self, img: &mut OtpImg) -> Result<VmemImage> {
+        // Seeded RNG needed for "<random>" values.
+        let mut rng = img.get_rng();
+        let mut vmem_partitions = Vec::<VmemPartition>::new();
+        for partition in &self.partitions {
+            let key_name = match partition.key_sel.as_str() {
+                "NoKey" => None,
+                key => Some(key.to_owned()),
+            };
+
+            let digest_type = if !partition.sw_digest && !partition.hw_digest {
+                DigestType::Unlocked
+            } else if partition.sw_digest && !partition.hw_digest {
+                DigestType::Software
+            } else if !partition.sw_digest && partition.hw_digest {
+                // Extra information needed to compute HW digests.
+                let iv_size = self.scrambling.iv_size;
+                let cnst_size = self.scrambling.cnst_size;
+                let digest_info = self
+                    .scrambling
+                    .digests
+                    .iter_mut()
+                    .find(|v| v.name == "CnstyDigest")
+                    .ok_or(anyhow!("Couldn't find digest info"))?;
+
+                const IV_SIZE: usize = std::mem::size_of::<DigestIV>();
+                const CNST_SIZE: usize = std::mem::size_of::<DigestCnst>();
+                let iv_value: [u8; IV_SIZE] = digest_info
+                    .iv_value
+                    .resolve(iv_size, &mut rng)
+                    .try_into()
+                    .map_err(|_| anyhow!("Bad IV size {}", iv_size))?;
+                let cnst_value: [u8; CNST_SIZE] = digest_info
+                    .cnst_value
+                    .resolve(cnst_size, &mut rng)
+                    .try_into()
+                    .map_err(|_| anyhow!("Bad scrambling constant size {}", cnst_size))?;
+                DigestType::Hardware(
+                    DigestIV::from_ne_bytes(iv_value),
+                    DigestCnst::from_ne_bytes(cnst_value),
+                )
+            } else {
+                bail!("Invalid digest configuration");
+            };
+
+            let mut vmem_partition = VmemPartition::new(
+                partition.name.clone(),
+                partition.size,
+                digest_type,
+                key_name,
+            );
+
+            // Fetch the img definition for partition, this contains the associated values for
+            // paritition items.
+            let mut img_partition = img.get_partition(&partition.name);
+
+            let mut offset = 0usize;
+
+            // Resolve all values and convert to Vmem representation.
+            for item in &partition.items {
+                let img_item_value = match &mut img_partition {
+                    Some(v) => {
+                        let item_value = v.get_item(&item.name);
+                        match item_value {
+                            Some(v) => v.value.resolve(item.size, &mut rng),
+                            None => vec![0u8; item.size],
+                        }
+                    }
+                    None => vec![0u8; item.size],
+                };
+                let vmem_item = VmemItem::new(img_item_value, offset, item.name.clone());
+                offset += item.size;
+                vmem_partition.push_item(vmem_item);
+            }
+            if partition.size == 0 {
+                const SCRAMBLE_BLOCK_WIDTH: usize = 8;
+                const DIGEST_SIZE: usize = 8;
+                let mut size = SCRAMBLE_BLOCK_WIDTH
+                    * ((offset + SCRAMBLE_BLOCK_WIDTH - 1) / SCRAMBLE_BLOCK_WIDTH);
+                if partition.hw_digest || partition.sw_digest {
+                    size += DIGEST_SIZE;
+                }
+                vmem_partition.set_size(size);
+            }
+            vmem_partitions.push(vmem_partition);
+        }
+        Ok(VmemImage::new(
+            vmem_partitions,
+            self.otp.width,
+            self.otp.depth,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::read_to_string;
+
+    #[test]
+    fn test_mmap_deserialize() {
+        let _: OtpMap =
+            deser_hjson::from_str(&read_to_string("tests/otp_ctrl_mmap.hjson").unwrap()).unwrap();
+    }
+
+    #[test]
+    fn test_img_deserialize() {
+        let _: OtpImg =
+            deser_hjson::from_str(&read_to_string("tests/otp_ctrl_img_dev.hjson").unwrap())
+                .unwrap();
+    }
+}
diff --git a/sw/host/opentitanlib/src/otp/vmem_serialize.rs b/sw/host/opentitanlib/src/otp/vmem_serialize.rs
new file mode 100644
index 0000000..077b46a
--- /dev/null
+++ b/sw/host/opentitanlib/src/otp/vmem_serialize.rs
@@ -0,0 +1,279 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::otp::lc_state::LcSecded;
+use crate::util::present::Present;
+
+use std::collections::HashMap;
+use std::convert::TryInto;
+use std::fmt::Write;
+
+use anyhow::{anyhow, bail, ensure, Result};
+
+use zerocopy::AsBytes;
+
+enum ItemType {
+    Bytes(Vec<u8>),
+    Unvalued(usize),
+}
+
+/// The hex representation of an OTP item.
+pub struct VmemItem {
+    value: ItemType,
+    offset: usize,
+    name: String,
+}
+
+impl VmemItem {
+    pub fn new(bytes: Vec<u8>, offset: usize, name: String) -> VmemItem {
+        VmemItem {
+            value: ItemType::Bytes(bytes),
+            offset,
+            name,
+        }
+    }
+
+    pub fn new_unvalued(size: usize, offset: usize, name: String) -> VmemItem {
+        VmemItem {
+            value: ItemType::Unvalued(size),
+            offset,
+            name,
+        }
+    }
+
+    pub fn size(&self) -> usize {
+        match &self.value {
+            ItemType::Bytes(b) => b.len(),
+            ItemType::Unvalued(size) => *size,
+        }
+    }
+}
+
+pub type DigestIV = u64;
+pub type DigestCnst = u128;
+
+/// Digest information for an OTP partition.
+#[derive(PartialEq)]
+pub enum DigestType {
+    Unlocked,
+    Software,
+    Hardware(DigestIV, DigestCnst),
+}
+
+/// The hex representation of an OTP partition.
+pub struct VmemPartition {
+    /// Items associated with this partition.
+    items: Vec<VmemItem>,
+    /// The name of this partition.
+    /// Used in annotations.
+    name: String,
+    /// The type of digest used for this partition.
+    /// For software digests, the value of the digest is provided and appended to the list of
+    /// items. For hardware digests, we must compute the digest value and append to the list of
+    /// items.
+    digest_type: DigestType,
+    /// Partition size.
+    size: usize,
+    /// The key name for this parition.
+    /// If specified, the serializer will attempt to scramble this parition using the key named in
+    /// this field.
+    key_name: Option<String>,
+}
+
+impl VmemPartition {
+    pub fn new(
+        name: String,
+        size: usize,
+        digest_type: DigestType,
+        key_name: Option<String>,
+    ) -> VmemPartition {
+        VmemPartition {
+            items: Vec::new(),
+            name,
+            digest_type,
+            size,
+            key_name,
+        }
+    }
+
+    /// Set the size of the partition.
+    ///
+    /// For partitions that don't specify their size, this is used to set the size of the partition
+    /// including the digest.
+    pub fn set_size(&mut self, size: usize) {
+        self.size = size;
+    }
+
+    /// Add an item to this partition.
+    pub fn push_item(&mut self, item: VmemItem) {
+        self.items.push(item);
+    }
+
+    /// Produces a tuple containing OTP HEX lines with annotations.
+    fn write_to_buffer(&self, keys: &HashMap<String, Vec<u8>>) -> Result<(Vec<u8>, Vec<String>)> {
+        if self.size % 8 != 0 {
+            bail!("Partition {} must be 64-bit alligned", self.name);
+        }
+
+        let mut defined = vec![false; self.size];
+        let mut annotations: Vec<String> = vec!["unallocated".to_owned(); self.size];
+
+        let mut data_bytes: Vec<u8> = vec![0; self.size];
+
+        for item in &self.items {
+            let end = item.offset + item.size();
+            annotations[item.offset..end].fill(format!("{}: {}", self.name, item.name).to_string());
+            let defined = &mut defined[item.offset..end];
+            if let Some(collision) = defined.iter().position(|defined| *defined) {
+                bail!(
+                    "Unexpected item collision with item {} at 0x{:x}",
+                    item.name,
+                    collision
+                );
+            }
+            defined.fill(true);
+            if let ItemType::Bytes(bytes) = &item.value {
+                data_bytes[item.offset..end].copy_from_slice(bytes);
+            }
+        }
+
+        let mut data_blocks = Vec::<u64>::new();
+        let mut data_blocks_defined = Vec::<bool>::new();
+        for (k, chunk) in data_bytes.chunks(8).enumerate() {
+            data_blocks.push(u64::from_le_bytes(chunk.try_into().unwrap()));
+            let byte_offset = k * 8;
+            data_blocks_defined.push(
+                defined[byte_offset..byte_offset + 8]
+                    .iter()
+                    .fold(false, |a, &b| a || b),
+            );
+        }
+
+        if let Some(key_name) = &self.key_name {
+            let key = keys
+                .get(key_name)
+                .ok_or_else(|| anyhow!("Key not found {}", key_name))?;
+
+            let cipher = Present::try_new(key.clone())?;
+
+            for i in 0..data_blocks.len() {
+                if data_blocks_defined[i] {
+                    data_blocks[i] = cipher.encrypt_block(data_blocks[i]);
+                }
+            }
+        }
+
+        if let DigestType::Hardware(iv, fin_const) = self.digest_type {
+            ensure!(
+                matches!(data_blocks.last(), None | Some(0)),
+                "Digest of partition {} cannot be overridden manually",
+                self.name
+            );
+            let last = data_blocks.len() - 1;
+            data_blocks[last] = present_digest_64(&data_blocks[0..last], iv, fin_const);
+        }
+
+        let data = data_blocks.as_bytes().to_vec();
+
+        if data.len() != self.size {
+            Err(anyhow!("Partition {} size mismatch", self.name))
+        } else {
+            Ok((data, annotations))
+        }
+    }
+}
+
+pub struct VmemImage {
+    partitions: Vec<VmemPartition>,
+    width: usize,
+    depth: usize,
+}
+
+impl VmemImage {
+    pub fn new(partitions: Vec<VmemPartition>, width: usize, depth: usize) -> VmemImage {
+        VmemImage {
+            partitions,
+            width,
+            depth,
+        }
+    }
+    pub fn generate(
+        &self,
+        keys: HashMap<String, Vec<u8>>,
+        secded: &LcSecded,
+    ) -> Result<Vec<String>> {
+        let mut data: Vec<u8> = vec![0; self.width * self.depth];
+        let mut annotations: Vec<String> = vec![Default::default(); data.len()];
+        let mut offset = 0;
+        for partition in &self.partitions {
+            let (part_data, part_annotation) = partition.write_to_buffer(&keys)?;
+            let end = offset + partition.size;
+            if end > data.len() {
+                bail!(
+                    "Partition {} out of bounds, ends at 0x{:x}",
+                    partition.name,
+                    end
+                );
+            }
+            data[offset..end].clone_from_slice(&part_data);
+            annotations[offset..end].clone_from_slice(&part_annotation);
+            offset += partition.size;
+        }
+
+        let width_ecc = self.width + secded.ecc_byte_len();
+        let num_words = data.len() / self.width;
+
+        let mut output = vec![format!(
+            "// OTP memory hexfile with {} x {}bit layout",
+            self.depth,
+            width_ecc * 8
+        )];
+
+        for i in 0..num_words {
+            let mut word = Vec::<u8>::new();
+            let mut word_annotation = Vec::<String>::new();
+            for j in 0..self.width {
+                let idx = i * self.width + j;
+                word.push(data[idx]);
+                if !word_annotation.contains(&annotations[idx]) {
+                    word_annotation.push(annotations[idx].clone());
+                }
+            }
+            let word_with_ecc = secded.ecc_encode(word)?;
+            let mut word_str = String::new();
+            for byte in word_with_ecc.iter().rev() {
+                write!(word_str, "{:02x}", byte)?;
+            }
+            output.push(format!(
+                "{} // {:06x}: {}",
+                word_str,
+                i * self.width,
+                word_annotation.join(", ")
+            ));
+        }
+
+        Ok(output)
+    }
+}
+
+fn present_digest_64(message: &[u64], iv: DigestIV, fin_const: DigestCnst) -> u64 {
+    let mut state = iv;
+    for i in (0..message.len() + 2).step_by(2) {
+        let b128: [u8; 16] = if i + 1 < message.len() {
+            (message[i] as u128) << 64 | message[i + 1] as u128
+        } else if i < message.len() {
+            (message[i] as u128) << 64 | message[i] as u128
+        } else {
+            fin_const
+        }
+        .as_bytes()
+        .try_into()
+        .unwrap();
+
+        let cipher = Present::new_128(&b128);
+        state ^= cipher.encrypt_block(state);
+    }
+
+    state
+}
diff --git a/sw/host/opentitanlib/src/util/mod.rs b/sw/host/opentitanlib/src/util/mod.rs
index 4d655de..1c3c7bf 100644
--- a/sw/host/opentitanlib/src/util/mod.rs
+++ b/sw/host/opentitanlib/src/util/mod.rs
@@ -7,8 +7,8 @@
 pub mod file;
 pub mod image;
 pub mod parse_int;
-pub mod usb;
 pub mod present;
+pub mod usb;
 pub mod voltage;
 
 /// The `collection` macro provides syntax for hash and set literals.
diff --git a/sw/host/opentitanlib/src/util/parse_int.rs b/sw/host/opentitanlib/src/util/parse_int.rs
index 1308013..6da3d48 100644
--- a/sw/host/opentitanlib/src/util/parse_int.rs
+++ b/sw/host/opentitanlib/src/util/parse_int.rs
@@ -73,6 +73,8 @@
 impl_parse_int!(u32);
 impl_parse_int!(i64);
 impl_parse_int!(u64);
+impl_parse_int!(i128);
+impl_parse_int!(u128);
 impl_parse_int!(isize);
 impl_parse_int!(usize);