diff --git a/ndncert/debian/control b/ndncert/debian/control
index 2af26f3..0e696ce 100644
--- a/ndncert/debian/control
+++ b/ndncert/debian/control
@@ -6,7 +6,7 @@
  python3 (>= 3.6.0),
  pkg-config (>= 0.29),
  libboost-all-dev (>= 1.65.1),
- libndn-cxx-dev (>= 0.6.5),
+ libndn-cxx-dev (>= 0.8.0),
  libsqlite3-dev (>= 3.22.0),
  libssl-dev (>= 1.1.1)
 Standards-Version: 3.9.2
@@ -28,7 +28,7 @@
 Depends: libndncert (= ${binary:Version}), ${misc:Depends},
  libboost-dev (>= 1.65.1),
  libboost-filesystem-dev (>= 1.65.1),
- libndn-cxx-dev,
+ libndn-cxx-dev (>= 0.8.0),
  libsqlite3-dev (>= 3.22.0),
  libssl-dev (>= 1.1.1)
 Description: NDN Certificate Management System
@@ -38,7 +38,7 @@
  This package contains the development files (headers and libraries)
 
 Package: libndncert-dbg
-Architecture: i386 amd64 arm64 armel armhf ppc64el
+Architecture: any
 Section: debug
 Depends: libndncert (= ${binary:Version}), ${misc:Depends}
 Description: NDN Certificate Management System (debugging symbols)
