diff --git a/src/config_parser.cpp b/src/config_parser.cpp
index 80f71e7..867d611 100644
--- a/src/config_parser.cpp
+++ b/src/config_parser.cpp
@@ -5,6 +5,7 @@
 
 #include <functional>
 #include <iterator>
+#include <stdexcept>
 #include <stdplus/exception.hpp>
 #include <stdplus/fd/create.hpp>
 #include <stdplus/fd/line.hpp>
@@ -67,7 +68,7 @@
         {
             continue;
         }
-        return &kit->second.back();
+        return &kit->second.back().get();
     }
     return nullptr;
 }
@@ -79,6 +80,42 @@
                      [](const Value& v) { return std::string(v); });
 }
 
+void KeyCheck::operator()(const std::string& s)
+{
+    for (auto c : s)
+    {
+        if (c == '\n' || c == '=')
+        {
+            throw std::invalid_argument(
+                fmt::format(FMT_COMPILE("Invalid Config Key: {}"), s));
+        }
+    }
+}
+
+void SectionCheck::operator()(const std::string& s)
+{
+    for (auto c : s)
+    {
+        if (c == '\n' || c == ']')
+        {
+            throw std::invalid_argument(
+                fmt::format(FMT_COMPILE("Invalid Config Section: {}"), s));
+        }
+    }
+}
+
+void ValueCheck::operator()(const std::string& s)
+{
+    for (auto c : s)
+    {
+        if (c == '\n')
+        {
+            throw std::invalid_argument(
+                fmt::format(FMT_COMPILE("Invalid Config Value: {}"), s));
+        }
+    }
+}
+
 Parser::Parser(const fs::path& filename)
 {
     setFile(filename);
@@ -145,8 +182,8 @@
         auto it = sections.find(s);
         if (it == sections.end())
         {
-            std::tie(it, std::ignore) =
-                sections.emplace(Section(s), KeyValuesMapList{});
+            std::tie(it, std::ignore) = sections.emplace(
+                Section(Section::unchecked(), s), KeyValuesMapList{});
         }
         section = &it->second.emplace_back();
     }
@@ -181,9 +218,10 @@
         auto it = section->find(k);
         if (it == section->end())
         {
-            std::tie(it, std::ignore) = section->emplace(Key(k), ValueList{});
+            std::tie(it, std::ignore) =
+                section->emplace(Key(Key::unchecked(), k), ValueList{});
         }
-        it->second.emplace_back(v);
+        it->second.emplace_back(Value::unchecked(), v);
     }
 
     void pump(std::string_view line)
diff --git a/src/config_parser.hpp b/src/config_parser.hpp
index 9b203c2..6b633e9 100644
--- a/src/config_parser.hpp
+++ b/src/config_parser.hpp
@@ -3,6 +3,7 @@
 #include <filesystem>
 #include <functional>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <string_view>
 #include <unordered_map>
@@ -25,14 +26,98 @@
 fs::path pathForIntfConf(const fs::path& dir, std::string_view intf);
 fs::path pathForIntfDev(const fs::path& dir, std::string_view intf);
 
+template <typename T, typename Check>
+class Checked
+{
+  public:
+    struct unchecked
+    {
+    };
+
+    template <typename... Args>
+    inline constexpr Checked(Args&&... args) :
+        t(conCheck(std::forward<Args>(args)...))
+    {
+    }
+
+    template <typename... Args>
+    inline constexpr Checked(unchecked, Args&&... args) :
+        t(std::forward<Args>(args)...)
+    {
+    }
+
+    inline const T& get() const noexcept
+    {
+        return t;
+    }
+
+    inline constexpr operator const T&() const noexcept
+    {
+        return t;
+    }
+
+    inline constexpr bool operator==(const auto& rhs) const
+    {
+        return t == rhs;
+    }
+
+  private:
+    T t;
+
+    template <typename... Args>
+    inline static constexpr T conCheck(Args&&... args)
+    {
+        T t(std::forward<Args>(args)...);
+        Check{}(t);
+        return t;
+    }
+};
+
+template <typename T, typename Check>
+inline constexpr bool operator==(const auto& lhs, const Checked<T, Check>& rhs)
+{
+    return lhs == rhs.get();
+}
+
+template <typename T, typename Check>
+inline constexpr std::ostream& operator<<(std::ostream& s,
+                                          const Checked<T, Check>& rhs)
+{
+    return s << rhs.get();
+}
+
+struct KeyCheck
+{
+    void operator()(const std::string& s);
+};
+struct SectionCheck
+{
+    void operator()(const std::string& s);
+};
+struct ValueCheck
+{
+    void operator()(const std::string& s);
+};
+
 struct string_hash : public std::hash<std::string_view>
 {
     using is_transparent = void;
+
+    template <typename T>
+    inline size_t operator()(const Checked<std::string, T>& t) const
+    {
+        return static_cast<const std::hash<std::string_view>&>(*this)(t.get());
+    }
+    template <typename T>
+    inline size_t operator()(const T& t) const
+    {
+        return static_cast<const std::hash<std::string_view>&>(*this)(t);
+    }
 };
 
-using Key = std::string;
-using Section = std::string;
-using Value = std::string;
+using Key = Checked<std::string, KeyCheck>;
+using Section = Checked<std::string, SectionCheck>;
+using Value = Checked<std::string, ValueCheck>;
 using ValueList = std::vector<Value>;
 using KeyValuesMap =
     std::unordered_map<Key, ValueList, string_hash, std::equal_to<>>;
diff --git a/test/test_config_parser.cpp b/test/test_config_parser.cpp
index 909ad7f..e7d44ef 100644
--- a/test/test_config_parser.cpp
+++ b/test/test_config_parser.cpp
@@ -49,6 +49,31 @@
     EXPECT_FALSE(parseBool("oFf").value());
 }
 
+TEST(TestTypeChecking, Section)
+{
+    Section("");
+    Section("fds#1!'\"");
+    EXPECT_THROW(Section("fds]sf"), std::invalid_argument);
+    EXPECT_THROW(Section("g\ng"), std::invalid_argument);
+}
+
+TEST(TestTypeChecking, Value)
+{
+    Value("");
+    Value("=fds1!'\"#=");
+    Value("fds]sf'' #");
+    EXPECT_THROW(Value("g\ng"), std::invalid_argument);
+}
+
+TEST(TestTypeChecking, Key)
+{
+    Key("");
+    Key("fds1!'\"#");
+    Key("fds]sf'' #");
+    EXPECT_THROW(Key("fds]sf'='"), std::invalid_argument);
+    EXPECT_THROW(Key("g\ng"), std::invalid_argument);
+}
+
 class TestConfigParser : public stdplus::gtest::TestWithTmp
 {
   public: