diff --git a/Cargo.toml b/Cargo.toml
index af65514..84b0fa7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,3 +10,5 @@ log = "*"
 rand = "*"
 num = "*"
 enum_primitive = "*"
+rustc-serialize = "*"
+chrono = "*"
diff --git a/src/der/bit_string.rs b/src/der/bit_string.rs
new file mode 100644
index 0000000..e621d68
--- /dev/null
+++ b/src/der/bit_string.rs
@@ -0,0 +1,63 @@
+use der::{Tag, FromValue, DerResult};
+use super::DerErrorKind::InvalidVal;
+
+// there are *two* BIT STRING types.
+// the first one is, well, bit vector.
+// all bits except for unused ones are meaningful:
+// for example, `0000_0000` != `0000` since the first one has 8 bits
+// but the second one has 4 bits.
+//
+// the second one is bitfield structure. this works in a different way!
+// for example, in the following structure:
+// ```
+// example ::= BIT STRING {
+//     first (0),
+//     second (1),
+//     third (2)
+// }
+// ```
+//
+// `{ first = false, second = true, third = false }` is encoded to `01`,
+// not `010`. that is, all trailing zeros are removed.
+// it is specified in x.680 (22.7) and x.690 (11.2.2) in a horrible way.
+//
+// this module only defines the first bit vector type. for the second one,
+// use `bit_string_fields` macro.
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct BitString {
+    pub unused_bits: u8,
+    pub data: Vec<u8>,
+}
+
+from_value!(BitString: Tag::BitString);
+
+/// Parse DER value and return (unused bits, bitstring value).
+pub fn from_der<'a>(value: &'a [u8]) -> DerResult<(u8, &'a [u8])> {
+    let len = value.len();
+    if len == 0 {
+        return der_err!(InvalidVal, "found zero-length BitString");
+    }
+
+    let unused_bits = value[0];
+    if unused_bits >= 8 {
+        return der_err!(InvalidVal, "unused bits >= 8 found");
+    }
+    if unused_bits > 0 && len == 1 {
+        return der_err!(InvalidVal, "unused bits != 0 but no bits found");
+    }
+
+    Ok((unused_bits, &value[1..]))
+}
+
+impl FromValue for BitString {
+    fn from_value(value: &[u8]) -> DerResult<BitString> {
+        let (unused_bits, data) = try!(from_der(value));
+        let data = data.to_vec();
+
+        Ok(BitString {
+            unused_bits: unused_bits,
+            data: data,
+        })
+    }
+}
diff --git a/src/der/macros.rs b/src/der/macros.rs
new file mode 100644
index 0000000..801ab82
--- /dev/null
+++ b/src/der/macros.rs
@@ -0,0 +1,405 @@
+// TODO remove debug line
+macro_rules! der_err {
+    ($kind:expr, $($args:tt)*) => ({
+        let e = format!($($args)*);
+        let e = format!("{} {} / {}", file!(), line!(), e);
+        ::der::DerError::new($kind, e)
+    })
+}
+
+macro_rules! from_sequence {
+    ($seq_name:ident) => (
+        impl $crate::der::FromTlv for $seq_name {
+            fn from_tlv(tag: $crate::der::Tag, value: &[u8]) -> $crate::der::DerResult<$seq_name> {
+                match tag {
+                    ::der::Tag::Sequence => {
+                        let seq_parser = $crate::der::reader::DerReader::new(value);
+                        let result: $seq_name = try!($seq_name::from_seq(seq_parser));
+                        Ok(result)
+                    }
+                    _ => return der_err!($crate::der::DerErrorKind::InvalidTag,
+                                         "unexpected tag: {:?}",
+                                         tag),
+                }
+            }
+        }
+
+    )
+}
+
+macro_rules! from_value {
+    ($ty_name:ty: $base_tag:pat) => (
+        impl ::der::FromTlv for $ty_name {
+            fn from_tlv(tag: ::der::Tag, value: &[u8]) -> ::der::DerResult<$ty_name> {
+                match tag {
+                    $base_tag => ::der::FromValue::from_value(value),
+                    _ => return der_err!($crate::der::DerErrorKind::InvalidTag,
+                                         "unexpected tag: {:?}",
+                                         tag),
+                }
+            }
+        }
+    )
+}
+
+macro_rules! ctx_sp {
+    (P, $e:expr) => (
+        ::der::Tag::Primitive($e, $crate::der::TagClass::ContextSpecific)
+    );
+    (C, $e:expr) => (
+        ::der::Tag::Constructed($e, $crate::der::TagClass::ContextSpecific)
+    );
+}
+
+macro_rules! sequence {
+    (
+        $(#[$a:meta])*
+        struct $seq_name:ident {
+            $(
+                $item_name:ident: $item_ty:ty,
+            )+
+        }
+    ) => (
+        sequence_opts!(
+            $(#[$a])*
+            struct $seq_name {
+                $(
+                    $item_name(): $item_ty,
+                )+
+            }
+        );
+    )
+}
+
+macro_rules! sequence_opts {
+    (
+        $(#[$a:meta])*
+        struct $seq_name:ident {
+            $(
+                $item_name:ident($($opts:tt)*): $item_ty:ty,
+            )+
+        }
+    ) => (
+        $(#[$a])*
+        #[derive(Debug)]
+        pub struct $seq_name {
+            $(
+                pub $item_name: $item_ty,
+            )+
+        }
+
+        from_sequence!($seq_name);
+
+        impl $seq_name {
+            fn from_seq(mut parser: $crate::der::reader::DerReader)
+            -> $crate::der::DerResult<$seq_name> {
+                $(
+                    let $item_name: $item_ty = {
+                        let ret = sequence_item!($item_ty, parser, $($opts)*);
+                        ret
+                    };
+                )+
+
+                if let Some((tag, value)) = try!(parser.peek_tlv()) {
+                    return der_err!($crate::der::DerErrorKind::InvalidTag,
+                                    "should be no element left, found {:?} in {}",
+                                    (tag, value),
+                                    stringify!($seq_name));
+                }
+
+                Ok($seq_name {
+                    $(
+                        $item_name: $item_name,
+                    )+
+                })
+            }
+        }
+    )
+}
+
+macro_rules! sequence_item {
+    ($t:ty, $parser:expr,) => ({
+        let (tag, value) = try!($parser.next_tlv());
+        let result: $t = try!($crate::der::FromTlv::from_tlv(tag, value));
+        result
+    });
+    ($t:ty, $parser:expr, OPTIONAL, $($tag:path),+) => ({
+        match try!($parser.peek_tlv()) {
+            None => None,
+            Some((tag, value)) => {
+                if $(tag == $tag)||+ {
+                    $parser.bump();
+                    // `$t` is `Option<T>`
+                    let result: $t = Some(try!($crate::der::FromTlv::from_tlv(tag, value)));
+                    result
+                } else {
+                    None
+                }
+            }
+        }
+    });
+    ($t:ty, $parser:expr, DEFAULT, $default:expr, $($tag:path),+) => ({
+        match try!($parser.peek_tlv()) {
+            None => $default,
+            Some((tag, value)) => {
+                if $(tag == $tag)||+ {
+                    $parser.bump();
+                    let result: $t = try!($crate::der::FromTlv::from_tlv(tag, value));
+                    // NOTE: DER requires `result != $default`,
+                    // but invalid cases are found in practice:
+                    // https://bugzilla.mozilla.org/show_bug.cgi?id=1031093
+                    // we may just have to disable it later.
+                    if result == $default {
+                        return der_err!($crate::der::DerErrorKind::InvalidVal,
+                                        "value identical to default: {}",
+                                        result);
+                    }
+                    result
+                } else {
+                    $default
+                }
+            }
+        }
+    });
+    ($t:ty, $parser:expr, IMPLICIT_OPTIONAL[$cls:ident:$id:expr], $orig_tag:path) => ({
+        match try!($parser.peek_tlv()) {
+            None => None,
+            Some((tag, value)) => {
+                if tag == ctx_sp!($cls, $id) {
+                    $parser.bump();
+                    let result: $t = Some(try!($crate::der::FromTlv::from_tlv($orig_tag, value)));
+                    result
+                } else {
+                    None
+                }
+            }
+        }
+    });
+    ($t:ty, $parser:expr, EXPLICIT_OPTIONAL[$cls:ident:$id:expr]) => ({
+        try!($parser.explicit(ctx_sp!($cls, $id),
+            |tag, value: &[u8]| {
+                let result = try!($crate::der::FromTlv::from_tlv(tag, value));
+                Ok(Some(result))
+            },
+            || Ok(None)
+        ))
+    });
+    ($t:ty, $parser:expr, EXPLICIT_DEFAULT[$cls:ident:$id:expr], $def:expr) => ({
+        try!($parser.explicit(ctx_sp!($cls, $id),
+            |tag, value: &[u8]| {
+                let result = try!($crate::der::FromTlv::from_tlv(tag, value));
+                Ok(result)
+            },
+            || Ok($def)
+        ))
+    });
+}
+
+macro_rules! sequence_of {
+    (
+        struct $seq_name:ident = $item_ty:ident($len_min:expr)
+    ) => (
+        #[derive(Debug)]
+        pub struct $seq_name {
+            pub seq: Vec<$item_ty>,
+        }
+
+        impl ::der::FromTlv for $seq_name {
+            fn from_tlv(tag: ::der::Tag, value: &[u8]) -> ::der::DerResult<$seq_name> {
+                match tag {
+                    ::der::Tag::Sequence => {
+                        let seq_parser = $crate::der::reader::DerReader::new(value);
+                        let value: $seq_name = try!($seq_name::from_seq(seq_parser));
+                        Ok(value)
+                    }
+                    _ => return der_err!($crate::der::DerErrorKind::InvalidTag,
+                                         "expected Seq, unexpected tag: {:?}",
+                                         tag),
+                }
+            }
+
+        }
+
+        impl $seq_name {
+            fn from_seq(mut parser: ::der::reader::DerReader) -> ::der::DerResult<$seq_name> {
+                let mut seq: Vec<$item_ty> = Vec::new();
+
+                while !parser.is_eof() {
+                    let (tag, value) = try!(parser.next_tlv());
+                    let item: $item_ty = try!($crate::der::FromTlv::from_tlv(tag, value));
+                    seq.push(item);
+                }
+
+                let len_min: usize = $len_min;
+
+                if seq.len() < len_min {
+                    return der_err!($crate::der::DerErrorKind::InvalidVal,
+                                    "sequence shorter than {}",
+                                    len_min);
+                }
+
+                Ok($seq_name {
+                    seq: seq,
+                })
+            }
+        }
+    )
+}
+
+macro_rules! bit_string_fields {
+    (
+        struct $name:ident {
+            $(
+                $bit_name:ident($i:expr),
+            )+
+        }
+    ) => (
+        #[derive(Debug)]
+        pub struct $name {
+            $(
+                pub $bit_name: bool,
+            )+
+        }
+
+        from_value!($name: Tag::BitString);
+
+        impl FromValue for $name {
+            fn from_value(value: &[u8]) -> DerResult<$name> {
+                let (unused_bits, value) = try!(::der::bit_string::from_der(value));
+                let total_bits = value.len() * 8 - unused_bits as usize;
+
+                // TODO `11100000` <- trailing bits should be disallowed
+                $(
+                    let byte_offset = $i / 8;
+                    let $bit_name: bool = if $i < total_bits {
+                        (value[byte_offset] >> (7 - ($i % 8))) & 1 == 1
+                    } else {
+                        false
+                    };
+                )+
+
+                Ok($name {
+                    $(
+                        $bit_name: $bit_name,
+                    )+
+                })
+            }
+        }
+    )
+}
+
+// parses the following form:
+// SEQUENCE {
+//     id OBJECT IDENTIFIER,
+//     value ANY DEFINED BY id
+// }
+macro_rules! enum_obj_id {
+    (
+        enum $enum_name:ident {
+            $(
+                $name:ident($t:ty) = $val:pat,
+            )+
+        }
+    ) => (
+        #[derive(Debug)]
+        pub enum $enum_name {
+            $(
+                $name($t),
+            )+
+
+            Unknown,
+        }
+
+        from_sequence!($enum_name);
+        impl $enum_name {
+            fn from_seq(mut reader: DerReader) -> DerResult<$enum_name> {
+                // FIXME: this exists only because `id` freezes reader.
+                #[derive(Debug)]
+                enum ObjId {
+                    $(
+                        $name,
+                    )+
+
+                    Unknown,
+                }
+
+                let ext = {
+                    let (tag, id) = try!(reader.next_tlv());
+                    if tag != Tag::ObjectIdentifier {
+                        return der_err!(::der::DerErrorKind::InvalidTag,
+                                        "expected ObjectIdentifier, found {:?}",
+                                        tag);
+                    }
+
+                    let ext = match id {
+                        $(
+                            $val => ObjId::$name,
+                        )+
+                        _ => ObjId::Unknown,
+                    };
+                    debug!("id: {:?} -> {:?}", id, ext);
+                    ext
+                };
+
+                match ext {
+                    $(
+                        ObjId::$name => {
+                            let (tag, value) = try!(reader.next_tlv());
+                            debug!("ext tag {:?} value {:?}", tag, value);
+                            let result: $t = try!(FromTlv::from_tlv(tag, value));
+                            if !reader.is_eof() {
+                                return der_err!(::der::DerErrorKind::InvalidTag,
+                                                "too many TLV elements");
+                            }
+                            debug!("result: {}, {:?}", stringify!($name), result);
+                            return Ok($enum_name::$name(result));
+                        }
+                    )+
+                    ObjId::Unknown => {
+                        return Ok($enum_name::Unknown);
+                    }
+                }
+            }
+        }
+    )
+}
+
+// macro for enum based on one-byte integer
+// e.g. `INTEGER { two-prime(0), multi(1) }`
+macro_rules! enum_integer {
+    (
+        enum $enum_name:ident {
+            $(
+                $name:ident = $val:pat,
+            )+
+        }
+    ) => (
+        #[derive(Debug)]
+        #[derive(PartialEq)]
+        pub enum $enum_name {
+            $(
+                $name,
+            )+
+        }
+
+        from_value!($enum_name: $crate::der::Tag::Integer);
+
+        impl $crate::der::FromValue for $enum_name {
+            fn from_value(value: &[u8]) -> $crate::der::DerResult<$enum_name> {
+                let len = value.len();
+                if len != 1 {
+                    return der_err!($crate::der::DerErrorKind::InvalidVal,
+                                    "expected length 1, found {}", len);
+                }
+                let value = match value[0] {
+                     $(
+                        $val => $enum_name::$name,
+                     )+
+                     other => return der_err!($crate::der::DerErrorKind::InvalidVal,
+                                              "unknown value: {}", other),
+                };
+                Ok(value)
+            }
+        }
+    )
+}
diff --git a/src/der/mod.rs b/src/der/mod.rs
new file mode 100644
index 0000000..58ef5d7
--- /dev/null
+++ b/src/der/mod.rs
@@ -0,0 +1,160 @@
+// DER reader
+
+use std::fmt;
+
+pub use self::reader::DerReader;
+pub use self::bit_string::BitString;
+pub use self::obj_id::ObjId;
+pub use self::time::Time;
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum DerErrorKind {
+    /// length field is too big or invalid
+    InvalidLen,
+    /// unknown or unsupported tag value found
+    InvalidTag,
+    /// unexpected eof while reading tlv
+    Eof,
+    /// value field has invalid data
+    InvalidVal,
+}
+
+#[derive(Debug)]
+pub struct DerError {
+    pub kind: DerErrorKind,
+    pub desc: String,
+}
+
+impl fmt::Display for DerError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        self.desc.fmt(f)
+    }
+}
+
+impl DerError {
+    pub fn new<T>(kind: DerErrorKind, desc: String) -> DerResult<T> {
+        Err(DerError {
+            kind: kind,
+            desc: desc,
+        })
+    }
+}
+
+pub type DerResult<T> = Result<T, DerError>;
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum TagClass {
+    Universal = 0b00,
+    Application = 0b01,
+    ContextSpecific = 0b10,
+    Private = 0b11,
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum Tag {
+    // primitives
+    Boolean, // 0x01
+    Integer, // 0x02
+    BitString, // 0x03
+    OctetString, // 0x04
+    Null, // 0x05
+    ObjectIdentifier, // 0x06
+    ObjectDescriptor, // 0x07
+    External, // 0x08
+    Real, // 0x09
+    Enumerated, // 0x0a
+    EmbeddedPdv, // 0x0b
+
+    // wow much string
+    Utf8String, // 0x0c
+    NumericString, // 0x12
+    PrintableString, // 0x13
+    TeletexString, // 0x14
+    VideotexString, // 0x15
+    Ia5String, // 0x16
+    GraphicString, // 0x19
+    VisibleString, // 0x1a
+    GeneralString, // 0x1b
+    UniversalString, // 0x1c
+    BmpString, // 0x1e
+
+    UtcTime, // 0x17
+    GeneralizedTime, // 0x18
+
+    // constructed
+    Sequence, // 0x10
+    Set, // 0x11
+
+    Primitive(u8, TagClass), // tag, tag_class
+    Constructed(u8, TagClass), //tag, tag_class
+}
+
+pub trait FromTlv {
+    fn from_tlv(tag: Tag, value: &[u8]) -> DerResult<Self>;
+}
+
+pub trait FromValue: FromTlv {
+    fn from_value(value: &[u8]) -> DerResult<Self>;
+}
+
+#[macro_use] pub mod macros;
+pub mod reader;
+
+// basic primitive types
+
+pub mod bit_string;
+pub mod obj_id;
+pub mod string;
+pub mod time;
+
+from_value!((): Tag::Null);
+impl FromValue for () {
+    fn from_value(value: &[u8]) -> DerResult<()> {
+        if value.len() != 0 {
+            return der_err!(DerErrorKind::InvalidVal, "Null with non-zero length");
+        }
+        Ok(())
+    }
+}
+
+from_value!(bool: Tag::Boolean);
+impl FromValue for bool {
+    fn from_value(value: &[u8]) -> DerResult<bool> {
+        if value.len() != 1 {
+            return der_err!(DerErrorKind::InvalidVal, "boolean with wrong length");
+        }
+        match value[0] {
+            0 => Ok(false),
+            255 => Ok(true),
+            _val => {
+                return der_err!(DerErrorKind::InvalidVal, "boolean with wrong value: {}", _val);
+            }
+        }
+    }
+}
+
+from_value!(Vec<u8>: Tag::OctetString);
+impl FromValue for Vec<u8> {
+    fn from_value(value: &[u8]) -> DerResult<Vec<u8>> {
+        Ok(value.to_vec())
+    }
+}
+
+#[derive(Debug)]
+pub struct Any(pub Tag, pub Vec<u8>);
+impl FromTlv for Any {
+    fn from_tlv(tag: Tag, value: &[u8]) -> DerResult<Any> {
+        Ok(Any(tag, value.to_vec()))
+    }
+}
+
+#[derive(Debug)]
+pub struct Integer(pub Vec<u8>);
+from_value!(Integer: Tag::Integer);
+impl FromValue for Integer {
+    fn from_value(value: &[u8]) -> DerResult<Integer> {
+        Ok(Integer(value.to_vec()))
+    }
+}
+
+#[cfg(test)] mod test;
diff --git a/src/der/obj_id.rs b/src/der/obj_id.rs
new file mode 100644
index 0000000..f19f62b
--- /dev/null
+++ b/src/der/obj_id.rs
@@ -0,0 +1,24 @@
+use super::{Tag, FromValue, DerResult};
+use super::DerErrorKind::InvalidVal;
+
+#[derive(PartialEq, Debug)]
+pub struct ObjId {
+    // DER encdoing of object identifier.
+    pub value: Vec<u8>,
+}
+
+from_value!(ObjId: Tag::ObjectIdentifier);
+
+impl FromValue for ObjId {
+    fn from_value(value: &[u8]) -> DerResult<ObjId> {
+        let len = value.len();
+
+        if len == 0 {
+            return der_err!(InvalidVal, "ObjectIdentifier with zero length");
+        }
+
+        Ok(ObjId {
+            value: value.to_vec()
+        })
+    }
+}
diff --git a/src/der/reader.rs b/src/der/reader.rs
new file mode 100644
index 0000000..71675ab
--- /dev/null
+++ b/src/der/reader.rs
@@ -0,0 +1,263 @@
+// # Notes
+//
+// -   DER only!
+// -   Tag must be `< 31` (long tag is not supported) and length must be `< 65536`.
+
+// TODO max_len
+
+use std::cell::Cell;
+use super::{Tag, TagClass};
+use super::DerResult;
+use super::DerErrorKind::{InvalidLen, InvalidTag, Eof};
+
+pub struct DerReader<'a> {
+    buf: &'a [u8],
+    pos: Cell<usize>,
+    cur: Option<(Tag, &'a [u8])>,
+}
+
+impl<'a> DerReader<'a> {
+    pub fn new(buf: &'a [u8]) -> DerReader<'a> {
+        DerReader {
+            buf: buf,
+            pos: Cell::new(0),
+            cur: None,
+        }
+    }
+}
+
+// internal utilities
+impl<'a> DerReader<'a> {
+    fn read_u8(&mut self) -> DerResult<u8> {
+        match self.buf.get(self.pos.get()) {
+            Some(&val) => {
+                self.pos.set(self.pos.get() + 1);
+                Ok(val)
+            }
+            None => return der_err!(Eof, "out-of-range"),
+        }
+    }
+
+    fn read_tag(&mut self) -> DerResult<Tag> {
+        let (tag_class, is_constructed, tag) = {
+            let b0 = try!(self.read_u8());
+            let class = match b0 >> 6 {
+                0b00 => TagClass::Universal,
+                0b01 => TagClass::Application,
+                0b10 => TagClass::ContextSpecific,
+                0b11 => TagClass::Private,
+                _ => unreachable!(),
+            };
+            let is_constructed = (b0 >> 5) & 0b1 == 0b1;
+
+            let tag = if b0 & 0b1_1111 == 0b1_1111 {
+                // tag can be > 31, but we just don't support it.
+                return der_err!(InvalidTag, "unsupported tag value > 31");
+            } else {
+                b0 & 0b1_1111
+            };
+
+            (class, is_constructed, tag)
+        };
+
+        let tag = if !is_constructed {
+            // primitives
+            if tag_class != TagClass::Universal {
+                Tag::Primitive(tag, tag_class)
+            } else {
+                match tag {
+                    0x00 => return der_err!(InvalidTag, "EndOfContents found in DER"),
+
+                    0x01 => Tag::Boolean,
+                    0x02 => Tag::Integer,
+                    0x03 => Tag::BitString,
+                    0x04 => Tag::OctetString,
+                    0x05 => Tag::Null,
+                    0x06 => Tag::ObjectIdentifier,
+                    0x07 => Tag::ObjectDescriptor,
+                    0x09 => Tag::Real,
+                    0x0a => Tag::Enumerated,
+                    0x0c => Tag::Utf8String,
+                    0x12 => Tag::NumericString,
+                    0x13 => Tag::PrintableString,
+                    0x14 => Tag::TeletexString,
+                    0x15 => Tag::VideotexString,
+                    0x16 => Tag::Ia5String,
+                    0x17 => Tag::UtcTime,
+                    0x18 => Tag::GeneralizedTime,
+                    0x19 => Tag::GraphicString,
+                    0x1a => Tag::VisibleString,
+                    0x1b => Tag::GeneralString,
+                    0x1c => Tag::UniversalString,
+                    0x1e => Tag::BmpString,
+
+                    0x08 | 0x0b | 0x10 | 0x11 => {
+                        return der_err!(InvalidTag, "Constructed tag found in Primitive: {}", tag);
+                    }
+                    _ => return der_err!(InvalidTag, "Unexpected tag in Primitive: {}", tag),
+                }
+            }
+        } else {
+            if tag_class != TagClass::Universal {
+                Tag::Constructed(tag, tag_class)
+            } else {
+                match tag {
+                    0x08 => Tag::External,
+                    0x0b => Tag::EmbeddedPdv,
+                    0x10 => Tag::Sequence,
+                    0x11 => Tag::Set,
+
+                    0x00 ... 0x0c | 0x12 ... 0x1e => {
+                        return der_err!(InvalidTag, "Primitive tag found in Constructed: {}", tag);
+                    }
+
+                    _ => return der_err!(InvalidTag, "Unexpected tag in Constructed: {}", tag),
+                }
+            }
+        };
+
+        Ok(tag)
+    }
+
+    // length is actually u16
+    fn read_len(&mut self) -> DerResult<usize> {
+        let len = {
+            let b0 = try!(self.read_u8());
+            if b0 == 0b1000_0000 {
+                return der_err!(InvalidLen, "indefinite length found in DER");
+            } else if b0 >> 7 == 1 {
+                // long form.
+                // FIXME: check "overlong" bytes e.g. 0x82 0x00 0x01
+                // I guess DER prohibits such one..
+                let lenlen = b0 & 0b111_1111;
+                if lenlen == 0b111_1111 {
+                    return der_err!(InvalidLen, "illegal length");
+                }
+                // we just don't expect >= 2^16 bytes.
+                if lenlen > 2 {
+                    return der_err!(InvalidLen, "unsupported length: {}", lenlen);
+                }
+                let mut len: u32 = 0;
+                for _i in 0..lenlen {
+                    let next = try!(self.read_u8());
+                    len = (len << 8) | (next as u32);
+                }
+                len as usize
+            } else {
+                b0 as usize
+            }
+        };
+
+        Ok(len)
+    }
+
+    fn read_value(&mut self, len: usize) -> DerResult<&'a [u8]> {
+        let new_pos = self.pos.get() + len;
+        if new_pos > self.buf.len() {
+            return der_err!(Eof, "length too large: {}", len);
+        }
+
+        let slice = &self.buf[self.pos.get() ..new_pos];
+        self.pos.set(self.pos.get() + len);
+        Ok(slice)
+    }
+}
+
+// basic methods
+impl<'a> DerReader<'a> {
+    pub fn is_eof(&self) -> bool {
+        self.cur == None && (self.buf.len() == self.pos.get())
+    }
+
+    // may return Ok(None) if eof
+    // call `.bump()` if returned tlv has been consumed
+    pub fn peek_tlv(&mut self) -> DerResult<Option<(Tag, &'a [u8])>> {
+        if self.is_eof() {
+            return Ok(None);
+        }
+        let (tag, len) = match self.cur {
+            None => {
+                let tag = try!(self.read_tag());
+                let len = try!(self.read_len());
+                let val = try!(self.read_value(len));
+                self.cur = Some((tag, val));
+                debug!("peek_tlv: tag {:?} val {:?}", tag, val);
+                (tag, val)
+            }
+            Some(tag_len) => tag_len
+        };
+        Ok(Some((tag, len)))
+    }
+
+    pub fn bump(&mut self) {
+        self.cur = None;
+    }
+
+    pub fn next_tlv(&mut self) -> DerResult<(Tag, &'a [u8])> {
+        match try!(self.peek_tlv()) {
+            None => der_err!(Eof, "end of stream when reading TLV"),
+            Some(next) => {
+                self.bump();
+                Ok(next)
+            }
+        }
+    }
+}
+
+// helpers
+impl<'a> DerReader<'a> {
+    pub fn explicit<T, F1, F2>(&mut self,
+                               expected_tag: Tag,
+                               mut matched: F1,
+                               mut unmatched: F2) -> DerResult<T> where
+        F1: FnMut(Tag, &[u8]) -> DerResult<T>,
+        F2: FnMut() -> DerResult<T>,
+    {
+        match try!(self.peek_tlv()) {
+            None => unmatched(),
+            Some((tag, value)) => {
+                if tag == expected_tag {
+                    self.bump();
+
+                    // actual data is wrapped in Constructed tag.
+                    let mut exp_parser = DerReader::new(value);
+
+                    let (tag, value) = try!(exp_parser.next_tlv());
+                    let result = try!(matched(tag, value));
+
+                    // only one should be packed?
+                    if let Some(some) = try!(exp_parser.peek_tlv()) {
+                        return der_err!(InvalidTag,
+                                        "unexpected tag {:?} inside {:?}",
+                                        some,
+                                        expected_tag);
+                    }
+
+                    Ok(result)
+                } else {
+                    unmatched()
+                }
+            }
+        }
+    }
+
+    pub fn default<T, F1, F2>(&mut self,
+                              expected_tag: Tag,
+                              mut matched: F1,
+                              mut unmatched: F2) -> DerResult<T> where
+        F1: FnMut(&[u8]) -> DerResult<T>,
+        F2: FnMut() -> DerResult<T>,
+    {
+        match try!(self.peek_tlv()) {
+            None => unmatched(),
+            Some((tag, value)) => {
+                if expected_tag == tag {
+                    self.bump();
+                    matched(value)
+                } else {
+                    unmatched()
+                }
+            }
+        }
+    }
+}
diff --git a/src/der/string.rs b/src/der/string.rs
new file mode 100644
index 0000000..c9c9bc3
--- /dev/null
+++ b/src/der/string.rs
@@ -0,0 +1,72 @@
+use std::str;
+use std::borrow::ToOwned;
+
+use der::{Tag, FromTlv, DerResult};
+use der::DerErrorKind::{InvalidTag, InvalidVal};
+
+// ASN.1 strings are jokes. there are so many string types with their own subtle rules
+// and some of the rules are ignored in wild.
+//
+// PrintableString doesn't allow '*' but some certs contain such values.
+// https://code.google.com/p/go/issues/detail?id=850
+// (mozilla pkix also accepts '*'.)
+//
+// PrintableString also doesn't allow '@', so you cannot print e-mail address.
+// Due to this, some legacy certs used IA5String where it cannot occur.
+//
+// there are *three* unicode strings. UniversalString and Utf8String are
+// basically same in ASN.1 but differently encoded in DER.
+// BMPString is.. BMP subset. encoded as ucs2.
+// (did you know ucs2 is big endian in spec?)
+//
+// also keep in mind that Rust doesn't accept invalid surrogates.
+// we will just treat such string as "invalid".
+
+// FIXME: I'm going to live with the std String for now.
+// I'm not saying this is unimportant; just saying that I'm tired right now and
+// I'll revise this in other day.
+
+impl FromTlv for String {
+    fn from_tlv(tag: Tag, value: &[u8]) -> DerResult<String> {
+        match tag {
+            Tag::Utf8String | Tag::PrintableString | Tag::Ia5String |
+            Tag::TeletexString | Tag::VisibleString => {
+                match str::from_utf8(value) {
+                    Ok(value) => Ok(value.to_owned()),
+                    Err(err) => return der_err!(InvalidVal, "invalid utf-8: {}, \"{:?}\"", err, value),
+                }
+            }
+            // TODO: UniversalString, BmpString
+            _ => return der_err!(InvalidTag, "unexpected tag \"{:?}\" for String", tag),
+        }
+    }
+}
+
+// TODO
+
+// pub struct PrintableString<'a>(&'a [u8]);
+
+// impl<'a> PrintableString<'a> {
+//     pub fn from_bytes(bytes: &'a [u8]) -> Option<PrintableString<'a>> {
+//         for b in bytes.iter() {
+//             match b {
+//                 b'A'...b'Z' | b'a'...b'z' | b'0'...b'9' | b' ' |
+//                 b'\'' | b'(' | b')' | b'+' | b',' | b'-' | b'.' | b'/' |
+//                 b':' | b'=' | b'?' => {}
+//                 _ => return None,
+//             }
+//         }
+//         Some(PrintableString(bytes))
+//     }
+// }
+
+// // TODO
+// #[derive(Debug)]
+// pub struct Ia5String(pub Vec<u8>);
+// from_value!(Ia5String: Tag::Ia5String);
+
+// impl FromValue for Ia5String {
+//     fn from_value(value: &[u8]) -> DerResult<Ia5String> {
+//         Ok(Ia5String(value.to_vec()))
+//     }
+// }
diff --git a/src/der/test.rs b/src/der/test.rs
new file mode 100644
index 0000000..ef91b32
--- /dev/null
+++ b/src/der/test.rs
@@ -0,0 +1,93 @@
+use der::{Tag, FromTlv, FromValue, DerResult, DerErrorKind};
+use der::reader::DerReader;
+
+macro_rules! assert_err {
+    ($e:expr, $expected:expr) => (
+        match $e {
+            Err(ref e) if e.kind == $expected => {}
+            actual => {
+                panic!("expected {:?}, found {:?}", $expected, actual);
+            }
+        }
+    )
+}
+
+#[derive(Debug, PartialEq)]
+pub struct OctetString(Vec<u8>);
+from_value!(OctetString: Tag::OctetString);
+impl FromValue for OctetString {
+    fn from_value(value: &[u8]) -> DerResult<OctetString> {
+        Ok(OctetString(value.to_vec()))
+    }
+}
+
+sequence_opts!(#[derive(PartialEq)] struct DefaultOptional {
+    default(DEFAULT, false, Tag::Boolean): bool,
+    optional(OPTIONAL, Tag::OctetString): Option<OctetString>,
+    null(): (),
+});
+
+#[test]
+fn test_default_optional() {
+    let ders: Vec<(Vec<u8>, DefaultOptional)> = vec![
+        (vec![0x30, 0x02, 0x05, 0x00], DefaultOptional {
+            default: false,
+            optional: None,
+            null: (),
+        }),
+        (vec![0x30, 0x05, 0x01, 0x01, 0xFF, 0x05, 0x00], DefaultOptional {
+            default: true,
+            optional: None,
+            null: (),
+        }),
+        (vec![0x30, 0x05, 0x04, 0x01, 0x12, 0x05, 0x00], DefaultOptional {
+            default: false,
+            optional: Some(OctetString(vec!(0x12))),
+            null: (),
+        }),
+        (vec![0x30, 0x08, 0x01, 0x01, 0xFF, 0x04, 0x01, 0x12, 0x05, 0x00], DefaultOptional {
+            default: true,
+            optional: Some(OctetString(vec!(0x12))),
+            null: (),
+        }),
+    ];
+
+    for &(ref der, ref expected) in ders.iter() {
+        let mut reader = DerReader::new(&der);
+        let (tag, value) = reader.next_tlv().unwrap();
+        let actual: DefaultOptional = FromTlv::from_tlv(tag, value).unwrap();
+        assert_eq!(expected, &actual);
+        assert!(reader.is_eof());
+    }
+}
+
+// http://www.intelsecurity.com/advanced-threat-research/berserk.html
+// http://www.intelsecurity.com/resources/wp-berserk-analysis-part-2.pdf
+#[test]
+fn test_length_overflow() {
+    let mut der = vec![0x05];
+    // 0x80 | 0x59, length is represented as 0x59-bytes.
+    let len = 0xd9;
+    der.push(len);
+    for _ in 0..(len - 4) {
+        der.push(0xff);
+    }
+    der.push_all(&[0x00, 0x00, 0x00, 0x02]);
+    // null
+    der.push_all(&[0x05, 0x00]);
+
+    let mut reader = DerReader::new(&der);
+    let next = reader.next_tlv();
+    assert_err!(next, DerErrorKind::InvalidLen);
+}
+
+// null should be null.
+#[test]
+fn test_null() {
+    let der = [0x05, 0x01, 0x01];
+
+    let mut reader = DerReader::new(&der);
+    let (tag, value) = reader.next_tlv().unwrap();
+    let null_or_err: DerResult<()> = FromTlv::from_tlv(tag, value);
+    assert_err!(null_or_err, DerErrorKind::InvalidVal);
+}
diff --git a/src/der/time.rs b/src/der/time.rs
new file mode 100644
index 0000000..d9a309c
--- /dev/null
+++ b/src/der/time.rs
@@ -0,0 +1,95 @@
+use chrono::{DateTime, UTC, TimeZone};
+
+use super::{Tag, DerResult, FromTlv};
+use super::DerErrorKind::{InvalidTag, InvalidVal};
+
+#[derive(Debug)]
+pub struct Time {
+    pub time: DateTime<UTC>,
+}
+
+impl FromTlv for Time {
+    fn from_tlv(tag: Tag, value: &[u8]) -> DerResult<Time> {
+        let val = match tag {
+            Tag::UtcTime => Time::from_utc_time(value),
+            Tag::GeneralizedTime => Time::from_gen_time(value),
+            _ => return der_err!(InvalidTag, "unexpected tag: {:?}", tag),
+        };
+        match val {
+            Some(val) => Ok(val),
+            None => return der_err!(InvalidVal, "invalid Time value"),
+        }
+    }
+}
+
+impl Time {
+    // value: YYMMDDhhmmss
+    fn from_date(y: &[u8], r: &[u8]) -> Option<Time> {
+        macro_rules! s(
+            ($v:ident, $i:expr) => ({
+                let val0 = $v[$i];
+                let val1 = $v[$i + 1];
+                if val0 < b'0' || val0 > b'9' || val1 < b'0' || val1 > b'9' {
+                    return None;
+                }
+                ((val0 - b'0') * 10 + (val1 - b'0')) as u32
+            })
+        );
+
+        let year = s!(y, 0) as i32;
+        let year = if y.len() == 4 {
+            year * 100 + (s!(y, 2) as i32)
+        } else {
+            if year >= 50 {
+                year + 1000
+            } else {
+                year + 2000
+            }
+        };
+
+        let month = s!(r, 0);
+        let day = s!(r, 2);
+        let hour = s!(r, 4);
+        let min = s!(r, 6);
+        let sec = s!(r, 8);
+
+        // hhmmss == '240000' is not permitted
+        if hour == 24 {
+            return None;
+        }
+
+        let time = UTC.ymd_opt(year, month, day).single()
+                .and_then(|s| { s.and_hms_opt(hour, min, sec) });
+
+        match time {
+            Some(time) => Some(Time { time: time }),
+            None => None,
+        }
+    }
+
+    fn from_gen_time(value: &[u8]) -> Option<Time> {
+        let len = value.len();
+        if len != 15 {
+            return None;
+        }
+
+        if value[14] != b'Z' {
+            return None;
+        }
+
+        Time::from_date(&value[..4], &value[4..14])
+    }
+
+    fn from_utc_time(value: &[u8]) -> Option<Time> {
+        let len = value.len();
+        if len != 13 {
+            return None;
+        }
+
+        if value[12] != b'Z' {
+            return None;
+        }
+
+        Time::from_date(&value[..2], &value[2..12])
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 529c5a7..15282ac 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,7 @@
 #![crate_type = "lib"]
 #![crate_name = "suruga"]
 
-#![feature(slice_bytes)]
+#![feature(slice_bytes, slice_patterns)]
 
 #[macro_use]
 extern crate log;
@@ -10,6 +10,8 @@ extern crate num;
 
 #[macro_use]
 extern crate enum_primitive;
+extern crate rustc_serialize; // base64
+extern crate chrono;
 
 pub use client::TlsClient;
 
@@ -17,6 +19,9 @@ pub use client::TlsClient;
 pub mod macros;
 pub mod util;
 
+#[macro_use]
+pub mod der;
+
 // basic crypto primitives
 pub mod crypto;
 
@@ -34,4 +39,7 @@ pub mod handshake;
 pub mod tls;
 pub mod client;
 
+#[macro_use]
+pub mod x509;
+
 #[cfg(test)] mod test;
diff --git a/src/x509/alg_id.rs b/src/x509/alg_id.rs
new file mode 100644
index 0000000..da41388
--- /dev/null
+++ b/src/x509/alg_id.rs
@@ -0,0 +1,19 @@
+use der::{Tag, FromTlv, DerResult, DerReader};
+
+// iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 1
+macro_rules! id_pkcs1 {
+    ($($e:expr),*) => ([42u8, 134, 72, 134, 247, 13, 1, 1, $($e),*])
+}
+
+enum_obj_id!(enum AlgId {
+    // RFC 3279
+    Rsa(()) = id_pkcs1!(1),
+    // RsaMd2(()) = id_pkcs1!(2),
+    // RsaMd5(()) = id_pkcs1!(4),
+    RsaSha1(()) = id_pkcs1!(5),
+
+    // RFC 4055
+    // "sha###WithRSAEncryption"
+    RsaSha224(()) = id_pkcs1!(14),
+    RsaSha256(()) = id_pkcs1!(11),
+});
diff --git a/src/x509/cert_serial_number.rs b/src/x509/cert_serial_number.rs
new file mode 100644
index 0000000..7270faf
--- /dev/null
+++ b/src/x509/cert_serial_number.rs
@@ -0,0 +1,32 @@
+use der::{Tag, FromValue, DerResult};
+use der::DerErrorKind::InvalidVal;
+
+// For some reason I will never understand, SerialNumber is packed into Integer.
+// This means serial number can be negative!
+#[derive(Debug)]
+pub struct CertificateSerialNumber {
+    pub val: Vec<u8>
+}
+
+from_value!(CertificateSerialNumber: Tag::Integer);
+
+impl FromValue for CertificateSerialNumber {
+    fn from_value(val: &[u8]) -> DerResult<CertificateSerialNumber> {
+        if val.len() == 0 {
+            return der_err!(InvalidVal, "zero-length CertificateSerialNumber");
+        }
+
+        if val.len() > 1 {
+            let v0 = val[0];
+            let v1 = val[1];
+
+            if (v0 == 0 && (v1 >> 7) == 0) || (v0 == 0xFF && (v1 >> 7) == 1) {
+                return der_err!(InvalidVal, "overlong bits");
+            }
+        }
+
+        Ok(CertificateSerialNumber {
+            val: val.to_vec()
+        })
+    }
+}
diff --git a/src/x509/certificate.rs b/src/x509/certificate.rs
new file mode 100644
index 0000000..6a4d149
--- /dev/null
+++ b/src/x509/certificate.rs
@@ -0,0 +1,49 @@
+use der::{Tag, FromTlv, DerReader, BitString};
+
+use super::CertResult;
+use super::alg_id::AlgId;
+use super::version::Version;
+use super::name::Name;
+use super::validity::Validity;
+use super::extension::ExtensionList;
+use super::cert_serial_number::CertificateSerialNumber;
+
+sequence!(struct SubjectPublicKeyInfo {
+    alg: AlgId,
+    subject_pub_key: BitString,
+});
+
+sequence_opts!(struct TbsCertificate {
+    version(EXPLICIT_DEFAULT[C:0], Version::Version1): Version,
+    serial_number(): CertificateSerialNumber,
+    signature(): AlgId,
+    issuer(): Name,
+    validity(): Validity,
+    subject(): Name,
+    subject_pub_key_info(): SubjectPublicKeyInfo,
+
+    // If present, version MUST be v2 or v3
+    issuer_unique_id(IMPLICIT_OPTIONAL[P:1], Tag::BitString): Option<BitString>,
+    subject_unique_id(IMPLICIT_OPTIONAL[P:2], Tag::BitString):  Option<BitString>,
+
+    extensions(EXPLICIT_OPTIONAL[C:3]): Option<ExtensionList>,
+});
+
+sequence!(struct Certificate {
+    cert: TbsCertificate,
+    sig_alg: AlgId,
+    sig_val: BitString,
+});
+
+impl Certificate {
+    /// Parse Certificate from DER bytes.
+    pub fn parse(cert: &[u8]) -> CertResult<Certificate> {
+        let mut parser = DerReader::new(cert);
+        let (tag, value) = try!(parser.next_tlv());
+        let cert = try!(FromTlv::from_tlv(tag, value));
+        Ok(cert)
+    }
+
+    // pub fn validate(&self, context: &ValidationContext) -> CertResult<()> {
+    // }
+}
diff --git a/src/x509/crl.rs b/src/x509/crl.rs
new file mode 100644
index 0000000..6126c81
--- /dev/null
+++ b/src/x509/crl.rs
@@ -0,0 +1,45 @@
+use der::{Tag, FromTlv, DerReader, BitString, Time};
+
+use super::alg_id::AlgId;
+use super::CertResult;
+use super::version::Version;
+use super::name::Name;
+use super::cert_serial_number::CertificateSerialNumber;
+use super::extension::ExtensionList;
+
+sequence_opts!(struct RevokedCert {
+    user_cert(): CertificateSerialNumber,
+    revoke_date(): Time,
+    // if Some, version must be v2
+    extensions(OPTIONAL, Tag::Sequence): Option<ExtensionList>,
+});
+
+sequence_of!(struct RevokedCertList = RevokedCert(0));
+
+sequence_opts!(struct TbsCertList {
+    // if Some, must be v2
+    version(OPTIONAL, Tag::Integer): Option<Version>,
+    signature(): AlgId,
+    issuer(): Name,
+    this_update(): Time,
+    next_update(OPTIONAL, Tag::UtcTime, Tag::GeneralizedTime): Option<Time>,
+    revoked_certs(OPTIONAL, Tag::Sequence): Option<RevokedCertList>,
+    // if Some, version must be v2
+    extensions(EXPLICIT_OPTIONAL[C:0]): Option<ExtensionList>,
+});
+
+sequence!(struct CertificateList {
+    cert_list: TbsCertList,
+    sig_alg: AlgId,
+    sig_val: BitString,
+});
+
+impl CertificateList {
+    /// Parse Certificate from DER bytes.
+    pub fn parse(cert: &[u8]) -> CertResult<CertificateList> {
+        let mut parser = DerReader::new(cert);
+        let (tag, value) = try!(parser.next_tlv());
+        let output = try!(FromTlv::from_tlv(tag, value));
+        Ok(output)
+    }
+}
diff --git a/src/x509/extension.rs b/src/x509/extension.rs
new file mode 100644
index 0000000..d683c65
--- /dev/null
+++ b/src/x509/extension.rs
@@ -0,0 +1,282 @@
+use der::{Tag, FromTlv, FromValue, DerResult};
+use der::{ObjId, Any, Integer};
+use der::reader::DerReader;
+use der::DerErrorKind::{InvalidVal, InvalidTag};
+
+use super::cert_serial_number::CertificateSerialNumber;
+use super::name::{Name, RelativeDistinguishedName};
+
+macro_rules! id_ce {
+    // 0x55 (joint-iso-ccitt(2) ds(5)) 29
+    ($($e:expr),*) => ([0x55, 29, $($e),*])
+}
+
+macro_rules! id_pkix {
+    // 0x2b (iso(1) identified-organization(3)) 6 1 5 5 7
+    ($($e:expr),*) => ([0x2b, 6, 1, 5, 5, 7, $($e),*])
+}
+
+macro_rules! id_pe {
+    ($($e:expr),*) => (id_pkix!(1, $($e),*))
+}
+
+macro_rules! id_qt {
+    ($($e:expr),*) => (id_pkix!(2, $($e),*))
+}
+
+// TODO all tagged typed should be reviewed again since most of them are
+// implicit but some of them are automatically forced to be explicit (wat)
+
+pub type Ia5String = String;
+
+// DisplayText ::= CHOICE {
+//     ia5String        IA5String      (SIZE (1..200)),
+//     visibleString    VisibleString  (SIZE (1..200)),
+//     bmpString        BMPString      (SIZE (1..200)),
+//     utf8String       UTF8String     (SIZE (1..200))
+// }
+pub type DisplayText = String;
+
+pub type KeyIdentifier = Vec<u8>;
+
+sequence_opts!(struct AuthorityKeyIdentifier {
+    key_identifier(IMPLICIT_OPTIONAL[P:0], Tag::OctetString): Option<KeyIdentifier>,
+    authority_cert_issuer(IMPLICIT_OPTIONAL[C:1], Tag::Sequence): Option<GeneralNames>,
+    authority_cert_serial_number(IMPLICIT_OPTIONAL[P:2], Tag::Integer):
+        Option<CertificateSerialNumber>,
+});
+
+bit_string_fields!(struct KeyUsage {
+    digital_signature(0),
+    // also known as non_repudiation.
+    content_commitment(1),
+    key_encipherment(2),
+    data_encipherment(3),
+    key_agreement(4),
+    key_cert_sign(5),
+    crl_sign(6),
+    encipher_only(7),
+    decipher_only(8),
+});
+
+sequence_opts!(struct UserNotice {
+    notice_ref(OPTIONAL, Tag::Sequence): Option<NoticeReference>,
+    explicit_text(OPTIONAL, Tag::Ia5String, Tag::VisibleString): Option<DisplayText>,
+});
+
+sequence_of!(struct IntegerSequence = Integer(0));
+
+sequence!(struct NoticeReference {
+    organization: DisplayText,
+    notice_numbers: IntegerSequence,
+});
+
+enum_obj_id!(enum PolicyQualifierInfo {
+    Cps(Ia5String) = id_qt!(1),
+    Unotice(UserNotice) = id_qt!(2),
+});
+
+sequence_of!(struct PolicyQualifiers = PolicyQualifierInfo(1));
+
+// Go x509 ignores qualifiers.
+sequence_opts!(struct PolicyInformation {
+    policy_identifier(): ObjId,
+    policy_qualifiers(OPTIONAL, Tag::Sequence): Option<PolicyQualifiers>,
+});
+
+sequence_of!(struct CertificatePolicies = PolicyInformation(1));
+
+// TODO see 4.2.1.6 for commented fields
+choice_tagged!(enum GeneralName {
+    [C:0] OtherName(IMPLICIT, Tag::Sequence): Any,
+    [P:1] Rfc822Name(IMPLICIT, Tag::Ia5String): Ia5String,
+    [P:2] DnsName(IMPLICIT, Tag::Ia5String): Ia5String,
+    // [3] X400Address(ORAddress),
+    // `Name` is CHOICE, so cannot be IMPLICIT. sigh
+    [C:4] DirectoryName(EXPLICIT): Name,
+    // [5] EdiPartyName(EDIPartyName),
+    [P:6] UniformResourceIdentifier(IMPLICIT, Tag::Ia5String): Ia5String,
+    // [7] IpAddress(OctetString),
+    // [8] RegisteredId(ObjId),
+});
+sequence_of!(struct GeneralNames = GeneralName(1));
+
+// sequence_of!(SubjectDirectoryAttributes = Attribute(1));
+
+// TODO it's silly to accept >1 bytes
+#[derive(Debug)]
+pub struct PathLenConstraints(Vec<u8>);
+from_value!(PathLenConstraints: Tag::Integer);
+
+impl FromValue for PathLenConstraints {
+    fn from_value(value: &[u8]) -> DerResult<PathLenConstraints> {
+        Ok(PathLenConstraints(value.to_vec()))
+    }
+}
+
+sequence_opts!(struct BasicConstraints {
+    ca(DEFAULT, false, Tag::Boolean): bool,
+    path_len_constraints(OPTIONAL, Tag::Integer): Option<PathLenConstraints>,
+});
+
+// 4.2.1.12 Extended Key Usage
+sequence_of!(struct ExtKeyUsageSyntax = ObjId(1));
+
+choice_tagged!(enum DistributionPointName {
+    [C:0] FullName(IMPLICIT, Tag::Sequence): GeneralNames,
+    [C:1] NameRelativeToCrlIssuer(IMPLICIT, Tag::Set): RelativeDistinguishedName,
+});
+bit_string_fields!(struct ReasonFlags {
+    unused(0),
+    key_compromise(1),
+    ca_compromise(2),
+    affiliation_changed(3),
+    superseded(4),
+    cessation_of_operation(5),
+    certificate_hold(6),
+    privilege_withdrawn(7),
+    aa_compromise(8),
+});
+// even if distributionPoint is implicit in the spec, DistributionPointName is
+// CHOICE which cannot be implicit, so it is *implicitly* explicit. sigh
+sequence_opts!(struct DistrubitionPoint {
+    distribution_point(EXPLICIT_OPTIONAL[C:0]): Option<DistributionPointName>,
+    reasons(IMPLICIT_OPTIONAL[P:1], Tag::BitString): Option<ReasonFlags>,
+    crl_issuer(IMPLICIT_OPTIONAL[C:2], Tag::Sequence): Option<GeneralNames>,
+});
+sequence_of!(struct CrlDistrubitionPoints = DistrubitionPoint(1));
+
+// 4.2.2.1
+sequence!(struct AccessDescription {
+    access_method: ObjId,
+    access_location: GeneralName,
+});
+sequence_of!(struct AuthorityInfoAccessSyntax = AccessDescription(1));
+
+// Extension ::= SEQUENCE {
+//     extn_id OBJECT IDENTIFIER,
+//     critical BOOLEAN DEFAULT FALSE,
+//     extn_value OCTET STRING
+// }
+// where `extn_value` is DER blob determined by extn_id.
+// note that this is different to `ANY` since it is wrapped in OctetString.
+macro_rules! extensions {
+    (
+        $(
+            $name:ident($t:ty) = $val:pat,
+        )+
+    ) => (
+        #[derive(Debug)]
+        pub enum Extension {
+            $(
+                $name($t),
+            )+
+
+            // .0: extension id
+            // .1: critical bit
+            // TODO: this may not a good design at all.. revisit this later
+            Unknown(Vec<u8>, bool),
+        }
+
+        from_sequence!(Extension);
+        impl Extension {
+            fn from_seq(mut reader: DerReader) -> DerResult<Extension> {
+                // FIXME: this exists only because `extn_id` freezes reader.
+                #[derive(Debug)]
+                enum ExtensionId {
+                    $(
+                        $name,
+                    )+
+
+                    Unknown(Vec<u8>),
+                }
+
+                let ext = {
+                    let (tag, extn_id) = try!(reader.next_tlv());
+                    if tag != Tag::ObjectIdentifier {
+                        return der_err!(InvalidTag, "expected ObjectIdentifier");
+                    }
+                    let ext = match extn_id {
+                        $(
+                            $val => ExtensionId::$name,
+                        )+
+                        unknown_id => ExtensionId::Unknown(unknown_id.to_vec()),
+                    };
+                    debug!("extension id: {:?} -> {:?}", extn_id, ext);
+                    ext
+                };
+
+                let critical = sequence_item!(bool, reader, DEFAULT, false, Tag::Boolean);
+                if let ExtensionId::Unknown(id) = ext {
+                    return Ok(Extension::Unknown(id, critical));
+                }
+
+                let (tag, extn_value) = try!(reader.next_tlv());
+                if tag != Tag::OctetString {
+                    return der_err!(InvalidTag, "expected OctetString");
+                }
+
+                match ext {
+                    $(
+                        ExtensionId::$name => {
+                            let mut ext_reader = DerReader::new(extn_value);
+                            let (ext_tag, ext_value) = try!(ext_reader.next_tlv());
+                            debug!("ext tag {:?} value {:?}", ext_tag, ext_value);
+                            let result: $t = try!(FromTlv::from_tlv(ext_tag, ext_value));
+                            if !ext_reader.is_eof() {
+                                return der_err!(InvalidTag, "too many TLV elements");
+                            }
+                            debug!("extension result: {}, {:?}", stringify!($name), result);
+                            return Ok(Extension::$name(result));
+                        }
+                    )+
+                    ExtensionId::Unknown(..) => unreachable!(),
+                }
+            }
+        }
+    )
+}
+
+extensions! {
+    // 4.2.1.1
+    AuthorityKeyIdentifier(AuthorityKeyIdentifier) = id_ce!(35),
+    // 4.2.1.2
+    SubjectKeyIdentifier(KeyIdentifier) = id_ce!(14),
+    // 4.2.1.3
+    KeyUsage(KeyUsage) = id_ce!(15),
+    // 4.2.1.4
+    CertificatePolicies(CertificatePolicies) = id_ce!(32),
+    // 4.2.1.5
+    // PolicyMappings(PolicyMappings) = id_ce!(33),
+    // 4.2.1.6
+    SubjectAltName(GeneralNames) = id_ce!(17),
+    // 4.2.1.7
+    IssuerAltName(GeneralNames) = id_ce!(18),
+    // 4.2.1.8
+    // SubjectDirectoryAttributes(SubjectDirectoryAttributes) = id_ce!(9),
+    // 4.2.1.9
+    BasicConstraints(BasicConstraints) = id_ce!(19),
+    // 4.2.1.10
+    // NameConstraints(NameConstraints) = id_ce!(30),
+    // 4.2.1.11
+    // PolicyConstraints(PolicyConstraints) = id_ce!(36),
+    // 4.2.1.12
+    ExtendedKeyUsage(ExtKeyUsageSyntax) = id_ce!(37),
+    // 4.2.1.13
+    CrlDistrubitionPoints(CrlDistrubitionPoints) = id_ce!(31),
+    // 4.2.1.14
+    // InhibitAnyPolicy(InhibitAnyPolicy) = id_ce!(54),
+    // 4.2.1.15
+    // FreshestCrl(CrlDistrubitionPoints) = id_ce!(46),
+
+    // 4.2.2.1
+    AuthorityInfoAccess(AuthorityInfoAccessSyntax) = id_pe!(1),
+    // 4.2.2.2
+    // SubjectInfoAccess(SubjectInfoAccess) = id_pe!(11),
+
+    // RFC 3709: Logotype, id_pe!(12)
+}
+
+// seems that some OCSP responses contain empty ExtensionList.
+// https://bugzilla.mozilla.org/show_bug.cgi?id=997994
+sequence_of!(struct ExtensionList = Extension(1));
diff --git a/src/x509/macros.rs b/src/x509/macros.rs
new file mode 100644
index 0000000..a8a7482
--- /dev/null
+++ b/src/x509/macros.rs
@@ -0,0 +1,41 @@
+macro_rules! choice_tagged {
+    (
+        enum $choice_name:ident {
+            $(
+                [$cls:ident:$id:expr] $name:ident($($opts:tt)*): $t:ty,
+            )+
+        }
+    ) => (
+        #[derive(Debug)]
+        pub enum $choice_name {
+            $(
+                $name($t),
+            )+
+        }
+
+        impl FromTlv for $choice_name {
+            fn from_tlv(tag: Tag, value: &[u8]) -> DerResult<$choice_name> {
+                $(
+                    if tag == ctx_sp!($cls, $id) {
+                        let item: $t = choice_tagged_item!($t, tag, value, $($opts)*);
+                        return Ok($choice_name::$name(item));
+                    }
+                )+
+                return der_err!(InvalidVal, "unexpected choice tag: {:?}", tag);
+            }
+        }
+    )
+}
+
+macro_rules! choice_tagged_item {
+    ($t:ty, $tag:expr, $value:expr, IMPLICIT, $new_tag:path) => ({
+        let choice_value: $t = try!(FromTlv::from_tlv($new_tag, $value));
+        choice_value
+    });
+    ($t:ty, $tag:expr, $value:expr, EXPLICIT) => ({
+        let mut exp_parser = DerReader::new($value);
+        let (exp_tag, exp_value) = try!(exp_parser.next_tlv());
+        let new_value: $t = try!(FromTlv::from_tlv(exp_tag, exp_value));
+        new_value
+    });
+}
diff --git a/src/x509/mod.rs b/src/x509/mod.rs
new file mode 100644
index 0000000..d65421d
--- /dev/null
+++ b/src/x509/mod.rs
@@ -0,0 +1,65 @@
+use std::error::Error;
+use std::fmt;
+use der;
+
+#[derive(PartialEq, Debug)]
+pub enum CertErrorKind {
+    ParseError,
+    InvalidField,
+    InvalidPeriod,
+}
+
+#[derive(Debug)]
+pub struct CertError {
+    pub kind: CertErrorKind,
+    pub desc: String,
+}
+
+impl CertError {
+    pub fn new<T>(kind: CertErrorKind, desc: String) -> CertResult<T> {
+        Err(CertError {
+            kind: kind,
+            desc: desc,
+        })
+    }
+}
+
+impl Error for CertError {
+    fn description(&self) -> &str {
+        match self.kind {
+            CertErrorKind::ParseError => "DER parse error",
+            CertErrorKind::InvalidField => "field has invalid value",
+            CertErrorKind::InvalidPeriod => "cert from past or future", // TODO horrible desc
+        }
+    }
+}
+
+impl fmt::Display for CertError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        self.desc.fmt(f)
+    }
+}
+
+impl From<der::DerError> for CertError {
+    fn from(err: der::DerError) -> CertError {
+        CertError {
+            kind: CertErrorKind::ParseError,
+            desc: format!("{:?}", err),
+        }
+    }
+}
+
+pub type CertResult<T> = Result<T, CertError>;
+
+#[macro_use]
+pub mod macros;
+
+pub mod pem;
+pub mod cert_serial_number;
+pub mod version;
+pub mod alg_id;
+pub mod name;
+pub mod validity;
+pub mod extension;
+pub mod certificate;
+pub mod crl;
diff --git a/src/x509/name.rs b/src/x509/name.rs
new file mode 100644
index 0000000..40023db
--- /dev/null
+++ b/src/x509/name.rs
@@ -0,0 +1,54 @@
+use der::{Tag, FromTlv, DerResult, DerReader, ObjId};
+use der::DerErrorKind::InvalidTag;
+
+// TODO full of hacks. parse attribute correctly
+
+pub type DirectoryString = String;
+
+sequence!(struct AttributeTypeAndValue {
+    attr_type: ObjId,
+    attr_value: DirectoryString,
+});
+
+// TODO set_of macro
+// SET SIZE (1..MAX) of AttributeTypeAndValue
+#[derive(Debug)]
+pub struct RelativeDistinguishedName {
+    set: Vec<AttributeTypeAndValue>,
+}
+
+impl FromTlv for RelativeDistinguishedName {
+    fn from_tlv(tag: Tag, value: &[u8]) -> DerResult<RelativeDistinguishedName> {
+        match tag {
+            Tag::Set => {
+                let set_parser = DerReader::new(value);
+                let value: RelativeDistinguishedName = try!(RelativeDistinguishedName::from_set(set_parser));
+                Ok(value)
+            }
+            _ => return der_err!(InvalidTag, "unexpected tag: {:?}", tag),
+        }
+    }
+}
+
+impl RelativeDistinguishedName {
+    fn from_set(mut parser: DerReader) -> DerResult<RelativeDistinguishedName> {
+        let mut set = Vec::new();
+
+        // TODO this currently throws error if nonunderstandable AttributeTypeAndValue is found.
+        // is it okay? we certainly need data for deciding it..
+        while !parser.is_eof() {
+            // TODO check sortness
+            let (tag, value) = try!(parser.next_tlv());
+            let item: AttributeTypeAndValue = try!(FromTlv::from_tlv(tag, value));
+            set.push(item);
+        }
+
+        Ok(RelativeDistinguishedName {
+            set: set,
+        })
+    }
+}
+
+// Name ::= CHOICE { RdnSequence }
+// RdnSequence ::= SEQUENCE OF RelativeDistinguishedName
+sequence_of!(struct Name = RelativeDistinguishedName(0));
diff --git a/src/x509/pem.rs b/src/x509/pem.rs
new file mode 100644
index 0000000..155bf8d
--- /dev/null
+++ b/src/x509/pem.rs
@@ -0,0 +1,143 @@
+use std::error::Error;
+use std::fmt;
+use std::io::{self, Read, BufRead, BufReader};
+use std::fs::File;
+use rustc_serialize::base64::{self, FromBase64};
+
+use util::ReadExt;
+
+#[derive(Debug)]
+pub enum PemError {
+    IoError(io::Error),
+    FormatError,
+    Base64Error(base64::FromBase64Error),
+}
+
+impl fmt::Display for PemError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl Error for PemError {
+    fn description(&self) -> &str {
+        match *self {
+            PemError::IoError(..) => "io failure",
+            PemError::FormatError => "cannot parse PEM header or footer",
+            PemError::Base64Error(..) => "cannot decode base64",
+        }
+    }
+}
+
+impl From<io::Error> for PemError {
+    fn from(err: io::Error) -> PemError {
+        PemError::IoError(err)
+    }
+}
+
+impl From<base64::FromBase64Error> for PemError {
+    fn from(err: base64::FromBase64Error) -> PemError {
+        PemError::Base64Error(err)
+    }
+}
+
+pub type PemResult<T> = Result<T, PemError>;
+
+pub struct PemReader {
+    inner: BufReader<File>,
+}
+
+impl PemReader {
+    pub fn new(file: File) -> PemReader {
+        PemReader {
+            inner: BufReader::new(file),
+        }
+    }
+}
+
+impl Iterator for PemReader {
+    type Item = PemResult<(Vec<u8>, Vec<u8>)>;
+
+    fn next(&mut self) -> Option<PemResult<(Vec<u8>, Vec<u8>)>> {
+        // return Err(PemError::FormatError) if expectation fails.
+        macro_rules! pem_expect {
+            ($actual:expr, $exp:expr) => ({
+                if $exp != $actual {
+                    return Some(Err(PemError::FormatError));
+                }
+            })
+        }
+
+        macro_rules! try_opt {
+            ($e:expr) => ({
+                match $e {
+                    Ok(e) => e,
+                    Err(e) => return Some(Err(From::from(e))),
+                }
+            })
+        }
+
+        // try to read one byte to check EOF..
+        let mut buf = [0u8];
+        let read = try_opt!(self.inner.read(&mut buf));
+        if read == 0 {
+            return None;
+        } else {
+            pem_expect!(buf[0], b'-');
+        }
+
+        let mut buf = [0u8; 4];
+        try_opt!(self.inner.fill_exact(&mut buf));
+        pem_expect!(buf[..], b"----"[..]);
+
+        let kind = {
+            let mut buf = vec![];
+            try_opt!(self.inner.read_until(b'-', &mut buf));
+            let len = buf.len();
+
+            // buf == b"BEGIN <SOMETHING>-"
+            pem_expect!(buf[..6], b"BEGIN "[..]);
+            pem_expect!(buf[len - 1], b'-');
+            buf[6..(len - 1)].to_vec()
+        };
+
+        let mut buf = [0u8; 5];
+        try_opt!(self.inner.fill_exact(&mut buf));
+        pem_expect!(buf[..], b"----\n"[..]);
+
+        let body = {
+            let mut body = vec![];
+            try_opt!(self.inner.read_until(b'-', &mut body));
+            let len = body.len();
+            if len == 0 {
+                return Some(Err(PemError::FormatError));
+            }
+            pem_expect!(body[len - 1], b'-');
+            body.truncate(len - 1);
+            try_opt!(body.from_base64())
+        };
+
+        let mut buf = [0u8; 4];
+        try_opt!(self.inner.fill_exact(&mut buf));
+        pem_expect!(buf[..], b"----"[..]);
+
+        let mut buf = vec![];
+        try_opt!(self.inner.read_until(b'-', &mut buf));
+        let len = buf.len();
+
+        // buf == b"END <SOMETHING>-"
+        pem_expect!(buf[..4], b"END "[..]);
+        pem_expect!(buf[len - 1], b'-');
+        pem_expect!(buf[4..(len - 1)], kind[..]);
+
+        let mut buf = [0u8; 5];
+        try_opt!(self.inner.fill_exact(&mut buf));
+        pem_expect!(buf[..], b"----\n"[..]);
+
+        Some(Ok((kind, body)))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, None)
+    }
+}
diff --git a/src/x509/validity.rs b/src/x509/validity.rs
new file mode 100644
index 0000000..3744481
--- /dev/null
+++ b/src/x509/validity.rs
@@ -0,0 +1,6 @@
+use der::Time;
+
+sequence!(struct Validity {
+    not_before: Time,
+    not_after: Time,
+});
diff --git a/src/x509/version.rs b/src/x509/version.rs
new file mode 100644
index 0000000..8f34f01
--- /dev/null
+++ b/src/x509/version.rs
@@ -0,0 +1,5 @@
+enum_integer!(enum Version {
+    Version1 = 0,
+    Version2 = 1,
+    Version3 = 2,
+});