diff --git a/src/lib/fuchsia-cxx/BUILD.gn b/src/lib/fuchsia-cxx/BUILD.gn
index 97198cc..862c8f9 100644
--- a/src/lib/fuchsia-cxx/BUILD.gn
+++ b/src/lib/fuchsia-cxx/BUILD.gn
@@ -14,7 +14,9 @@
   # It is recommended that you read https://docs.rs/cxx first to understand how cxx works, and to
   # understand what cxx does (and does not) do. All C++ code is still "unsafe" from the Rust
   # perspective; cxx just helps with building the Rust side of the FFI layer safely.
-  visibility = []
+  visibility = [
+    "//src/security/fcrypto-rust",
+  ]
 
   cxx_crate = "//third_party/rust_crates/vendor/cxx"
   sources = [
diff --git a/src/lib/fuchsia-cxx/rust_cxx_ffi_library.gni b/src/lib/fuchsia-cxx/rust_cxx_ffi_library.gni
index 01e486f4..b701f098 100644
--- a/src/lib/fuchsia-cxx/rust_cxx_ffi_library.gni
+++ b/src/lib/fuchsia-cxx/rust_cxx_ffi_library.gni
@@ -180,9 +180,10 @@
     deps = generation_targets + rust_deps
   }
 
+  crate_name = string_replace(package_name, "-", "_")
   generated_file(generated_rs_target) {
     outputs = [ "$source_gen_dir/staticlib_source_root.rs" ]
-    contents = "pub use " + package_name + "::*;"
+    contents = "pub use " + crate_name + "::*;"
   }
 
   # Create a staticlib from the rustc_library above. This uses a generated source_root that just
diff --git a/src/security/BUILD.gn b/src/security/BUILD.gn
index 99e1e52..83cb8d1 100644
--- a/src/security/BUILD.gn
+++ b/src/security/BUILD.gn
@@ -17,6 +17,7 @@
     "codelab:tests",
     "csa_helper:tests",
     "fcrypto:tests",
+    "fcrypto-rust:tests",
     "kms:tests",
     "scrutiny:tests",
     "tee_manager:tests",
diff --git a/src/security/fcrypto-rust/BUILD.gn b/src/security/fcrypto-rust/BUILD.gn
new file mode 100644
index 0000000..23cfee9
--- /dev/null
+++ b/src/security/fcrypto-rust/BUILD.gn
@@ -0,0 +1,53 @@
+# Copyright 2021 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/components.gni")
+import("//src/lib/fuchsia-cxx/rust_cxx_ffi_library.gni")
+
+rust_cxx_ffi_library("fcrypto-rust") {
+  name = "fcrypto_rust"
+  rust_source_root = "ffi.rs"
+  rust_sources = [ "ffi.rs" ]
+  bridge_sources = [ "ffi.rs" ]
+  rust_deps = [
+    "//src/lib/zircon/rust:fuchsia-zircon",
+    "//src/lib/zircon/rust:fuchsia-zircon-sys",
+    "//third_party/rust_crates:cxx",
+  ]
+  cpp_sources = [
+    "ffi.cc",
+    "ffi.h",
+  ]
+  public_deps = [ "//src/security/fcrypto" ]
+}
+
+rustc_test("fcrypto-rust-ffi-test") {
+  name = "fcrypto_rust_ffi_test"
+  edition = "2018"
+
+  source_root = "ffi_test.rs"
+  sources = [ "ffi_test.rs" ]
+
+  deps = [
+    ":fcrypto-rust",
+    "//src/lib/zircon/rust:fuchsia-zircon",
+    "//src/lib/zircon/rust:fuchsia-zircon-sys",
+    "//third_party/rust_crates:cxx",
+  ]
+}
+
+fuchsia_component("fcrypto-rust-test") {
+  testonly = true
+  manifest = "meta/fcrypto-rust-ffi-test.cml"
+  deps = [ ":fcrypto-rust-ffi-test" ]
+}
+
+fuchsia_test_package("fcrypto-rust-tests") {
+  test_components = [ ":fcrypto-rust-test" ]
+}
+
+group("tests") {
+  testonly = true
+  deps = [ ":fcrypto-rust-tests" ]
+}
diff --git a/src/security/fcrypto-rust/ffi.cc b/src/security/fcrypto-rust/ffi.cc
new file mode 100644
index 0000000..3692620
--- /dev/null
+++ b/src/security/fcrypto-rust/ffi.cc
@@ -0,0 +1,69 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/security/fcrypto-rust/ffi.h"
+
+#include <memory>
+
+#include "src/security/fcrypto/bytes.h"
+#include "src/security/fcrypto/cipher.h"
+#include "src/security/fcrypto/secret.h"
+
+namespace crypto {
+
+std::unique_ptr<Cipher> new_cipher() { return std::make_unique<Cipher>(); }
+
+static zx_status_t init_internal(Cipher& cipher, Cipher::Direction direction,
+                                 rust::Slice<const uint8_t>& secret, rust::Slice<const uint8_t>& iv,
+                                 uint64_t alignment) {
+  // Allocate Secret, Bytes
+  Secret crypto_secret;
+  zx_status_t rc;
+  uint8_t* secret_inner;
+  rc = crypto_secret.Allocate(secret.length(), &secret_inner);
+  if (rc != ZX_OK) {
+    return rc;
+  }
+
+  Bytes crypto_iv;
+  rc = crypto_iv.Resize(iv.length());
+  if (rc != ZX_OK) {
+    return rc;
+  }
+
+  // Populate the buffers.
+  memcpy(secret_inner, secret.data(), secret.length());
+  memcpy(crypto_iv.get(), iv.data(), iv.length());
+
+  return cipher.Init(crypto::Cipher::Algorithm::kAES256_XTS, direction, crypto_secret, crypto_iv,
+                     alignment);
+}
+
+zx_status_t init_for_encipher(Cipher& cipher, rust::Slice<const uint8_t> secret,
+                              rust::Slice<const uint8_t> iv, uint64_t alignment) {
+  return init_internal(cipher, Cipher::Direction::kEncrypt, secret, iv, alignment);
+}
+
+zx_status_t init_for_decipher(Cipher& cipher, rust::Slice<const uint8_t> secret,
+                              rust::Slice<const uint8_t> iv, uint64_t alignment) {
+  return init_internal(cipher, Cipher::Direction::kDecrypt, secret, iv, alignment);
+}
+
+zx_status_t encipher(Cipher& cipher, rust::Slice<const uint8_t> plaintext, uint64_t offset,
+                     rust::Slice<uint8_t> ciphertext) {
+  if (plaintext.length() != ciphertext.length()) {
+    return ZX_ERR_INVALID_ARGS;
+  }
+  return cipher.Encrypt(plaintext.data(), offset, plaintext.length(), ciphertext.data());
+}
+
+zx_status_t decipher(Cipher& cipher, rust::Slice<const uint8_t> ciphertext, uint64_t offset,
+                     rust::Slice<uint8_t> plaintext) {
+  if (plaintext.length() != ciphertext.length()) {
+    return ZX_ERR_INVALID_ARGS;
+  }
+  return cipher.Decrypt(ciphertext.data(), offset, ciphertext.length(), plaintext.data());
+}
+
+}  //  namespace crypto
diff --git a/src/security/fcrypto-rust/ffi.h b/src/security/fcrypto-rust/ffi.h
new file mode 100644
index 0000000..8cf3c83
--- /dev/null
+++ b/src/security/fcrypto-rust/ffi.h
@@ -0,0 +1,31 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_SECURITY_FCRYPTO_RUST_FFI_H_
+#define SRC_SECURITY_FCRYPTO_RUST_FFI_H_
+
+#include <zircon/status.h>
+
+#include "src/security/fcrypto/cipher.h"
+
+// Header generated from Rust cxxbridge declarations.  Include dir added by build template.
+#include "src/security/fcrypto-rust/ffi.rs.h"
+
+namespace crypto {
+
+std::unique_ptr<Cipher> new_cipher();
+
+zx_status_t init_for_encipher(Cipher& cipher, rust::Slice<const uint8_t> secret,
+                              rust::Slice<const uint8_t> iv, uint64_t alignment);
+zx_status_t init_for_decipher(Cipher& cipher, rust::Slice<const uint8_t> secret,
+                              rust::Slice<const uint8_t> iv, uint64_t alignment);
+
+zx_status_t encipher(Cipher& cipher, rust::Slice<const uint8_t> plaintext, uint64_t offset,
+                     rust::Slice<uint8_t> ciphertext);
+zx_status_t decipher(Cipher& cipher, rust::Slice<const uint8_t> ciphertext, uint64_t offset,
+                     rust::Slice<uint8_t> plaintext);
+
+}  // namespace crypto
+
+#endif  // SRC_SECURITY_FCRYPTO_RUST_FFI_H_
diff --git a/src/security/fcrypto-rust/ffi.rs b/src/security/fcrypto-rust/ffi.rs
new file mode 100644
index 0000000..c9a0f99
--- /dev/null
+++ b/src/security/fcrypto-rust/ffi.rs
@@ -0,0 +1,136 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// The `cxx` crate's expanded code appears to trigger this elided lifetimes in paths warning
+#![allow(elided_lifetimes_in_paths)]
+#![allow(dead_code)]
+
+use cxx::UniquePtr;
+use fuchsia_zircon_sys as sys;
+use std::pin::Pin;
+
+#[cxx::bridge(namespace = "crypto")]
+mod ffi {
+    // No shared structs
+
+    unsafe extern "C++" {
+        // C++ declarations
+        include!("src/security/fcrypto-rust/ffi.h");
+
+        type Cipher;
+
+        fn new_cipher() -> UniquePtr<Cipher>;
+
+        fn init_for_encipher(
+            cipher: Pin<&mut Cipher>,
+            secret: &[u8],
+            iv: &[u8],
+            alignment: u64,
+        ) -> i32;
+        fn init_for_decipher(
+            cipher: Pin<&mut Cipher>,
+            secret: &[u8],
+            iv: &[u8],
+            alignment: u64,
+        ) -> i32;
+
+        fn encipher(
+            cipher: Pin<&mut Cipher>,
+            plaintext: &[u8],
+            offset: u64,
+            ciphertext: &mut [u8],
+        ) -> i32;
+        fn decipher(
+            cipher: Pin<&mut Cipher>,
+            plaintext: &[u8],
+            offset: u64,
+            ciphertext: &mut [u8],
+        ) -> i32;
+    }
+}
+
+pub struct Aes256XtsCipher {
+    encipherer: Aes256XtsEncipherer,
+    decipherer: Aes256XtsDecipherer,
+}
+
+// TODO: make these failures return a better error type than i32
+impl Aes256XtsCipher {
+    pub fn new(secret: &[u8], iv: &[u8]) -> Result<Aes256XtsCipher, i32> {
+        // Allocate a pair of C++ Cipher objects.
+        let encipher_inner = ffi::new_cipher();
+        let decipher_inner = ffi::new_cipher();
+        let mut encipherer = Aes256XtsEncipherer { inner: encipher_inner };
+        let mut decipherer = Aes256XtsDecipherer { inner: decipher_inner };
+
+        encipherer.init(secret, iv)?;
+        decipherer.init(secret, iv)?;
+
+        Ok(Aes256XtsCipher { encipherer, decipherer })
+    }
+
+    pub fn encrypt(&mut self, offset: u64, plaintext: &[u8], ciphertext: &mut [u8]) -> Result<(), i32> {
+        self.encipherer.encipher(offset, plaintext, ciphertext)
+    }
+
+    pub fn decrypt(&mut self, offset: u64, ciphertext: &[u8], plaintext: &mut [u8]) -> Result<(), i32> {
+        self.decipherer.decipher(offset, ciphertext, plaintext)
+    }
+}
+
+pub struct Aes256XtsEncipherer {
+    inner: UniquePtr<ffi::Cipher>,
+}
+
+pub struct Aes256XtsDecipherer {
+    inner: UniquePtr<ffi::Cipher>,
+}
+
+const ALIGN: u64 = 128;
+
+impl Aes256XtsEncipherer {
+    fn init(&mut self, secret: &[u8], iv: &[u8]) -> Result<(), i32> {
+        let mut cref = self.inner.as_mut().ok_or(sys::ZX_ERR_INVALID_ARGS)?;
+        let res = ffi::init_for_encipher(Pin::as_mut(&mut cref), secret, iv, ALIGN);
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(res)
+        }
+    }
+
+    fn encipher(&mut self, offset: u64, plaintext: &[u8], ciphertext: &mut [u8]) -> Result<(), i32> {
+        assert!(plaintext.len() == ciphertext.len());
+        let mut cref = self.inner.as_mut().ok_or(sys::ZX_ERR_INVALID_ARGS)?;
+        let res = ffi::encipher(Pin::as_mut(&mut cref), plaintext, offset, ciphertext);
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(res)
+        }
+    }
+}
+
+impl Aes256XtsDecipherer {
+    fn init(&mut self, secret: &[u8], iv: &[u8]) -> Result<(), i32> {
+        let mut cref = self.inner.as_mut().ok_or(sys::ZX_ERR_INVALID_ARGS)?;
+        let res = ffi::init_for_decipher(Pin::as_mut(&mut cref), secret, iv, ALIGN);
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(res)
+        }
+    }
+
+    fn decipher(&mut self, offset: u64, ciphertext: &[u8], plaintext: &mut [u8]) -> Result<(), i32> {
+        assert!(plaintext.len() == ciphertext.len());
+        let mut cref = self.inner.as_mut().ok_or(sys::ZX_ERR_INVALID_ARGS)?;
+        let res = ffi::decipher(Pin::as_mut(&mut cref), ciphertext, offset, plaintext);
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(res)
+        }
+    }
+}
diff --git a/src/security/fcrypto-rust/ffi_test.rs b/src/security/fcrypto-rust/ffi_test.rs
new file mode 100644
index 0000000..eefb48e
--- /dev/null
+++ b/src/security/fcrypto-rust/ffi_test.rs
@@ -0,0 +1,17 @@
+// TODO: write a test that makes use of the AES-256-XTS bindings with some test vectors
+
+#![allow(elided_lifetimes_in_paths)]
+
+use fcrypto_rust::Aes256XtsCipher;
+
+#[test]
+fn test_cipher() {
+  // TODO: double-check these lengths
+  let key = [0u8; 32];
+  let iv = [0u8; 32];
+  let mut cipher = Aes256XtsCipher::new(&key, &iv).expect("create and init cipher");
+  let ctext = [0u8 ; 128];
+  let mut ptext = [0u8 ; 128];
+  cipher.encrypt(0, &ctext, &mut ptext).expect("encrypt");
+}
+
diff --git a/src/security/fcrypto-rust/meta/fcrypto-rust-ffi-test.cml b/src/security/fcrypto-rust/meta/fcrypto-rust-ffi-test.cml
new file mode 100644
index 0000000..4b32576
--- /dev/null
+++ b/src/security/fcrypto-rust/meta/fcrypto-rust-ffi-test.cml
@@ -0,0 +1,12 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+{
+    include: [
+        "//src/sys/test_runners/rust/default.shard.cml",
+        "syslog/client.shard.cml",
+    ],
+    program: {
+        binary: "bin/fcrypto_rust_ffi_test",
+    },
+}