Use octet strings to decode bit strings.

Author: sephynox

index.d.ts

@@ -20,7 +20,7 @@ export interface ASN1ContextTag {
   value: number
   contains: any
 }
-/** ASN1 JS bitstring. */
+/** ASN1 JS bit string. */
 export interface ASN1BitString {
   type: 'bitstring'
   value: Buffer
@@ -51,7 +51,11 @@ export function JStoASN1(
     | any[]
     | null,
 ): ASN1Encoder
-/** Convert ASN1 BER encoded data to JS native types. */
+/**
+ * Convert ASN1 BER encoded data to JS native types.
+ * This supports number arrays, Buffer, ArrayBufferLike, base64 or hex
+ * encded strings, or null input.
+ */
 export function ASN1toJS(
   data: string | null | number[] | Buffer | ArrayBuffer,
 ):
@@ -68,15 +72,18 @@ export function ASN1toJS(
   | boolean
   | any[]
   | null
-/** Convert ASN1 BER encoded data to JS native types. */
+/**
+ * Convert ASN1 BER encoded data to JS native types. This is the main decoder
+ * class for decoding ASN1 encoded data.
+ */
 export class ASN1Decoder {
-  /** Js constructor */
+  /** JS constructor. */
   constructor(data: string | null | number[] | Buffer | ArrayBuffer)
   /** Create an instance of ANS1 from a buffer. */
   static fromBuffer(value: Buffer): ASN1Decoder
   /** Create an instance of ANS1 from Base64 encoded data. */
   static fromBase64(value: string): ASN1Decoder
-  /** Create an instance of ANS1 from hex encoded data */
+  /** Create an instance of ANS1 from hex encoded data. */
   static fromHex(value: string): ASN1Decoder
   /** Convert to an integer. */
   intoInteger(): number
@@ -103,6 +110,10 @@ export class ASN1Decoder {
   /** Convert a Sequence to an Array. */
   intoArray(): any[]
 }
+/**
+ * Convert ASN1Data into ASN1 encoded data. This is the main encoder
+ * class for encoding to ASN1 encoded data.
+ */
 export class ASN1Encoder {
   /** Create a new ASN1Encoder instance from any ASN1 encodable type. */
   constructor(
@@ -127,4 +138,9 @@ export class ASN1Encoder {
   /** Encode the ASN.1 data to a ASN.1 encoded base64 encoded string. */
   toBase64(): string
 }
+/**
+ * ASN1 Iterator for sequences. Sequences use lazy loading iterators allowing
+ * for chaining of operations while only executing on a consumer ensuring
+ * O(n) operations.
+ */
 export class ASN1Iterator {}

src/asn1.rs

@@ -6,8 +6,7 @@ use napi::{
 };
 use num_bigint::BigInt;
 use rasn::{
-    ber::{de::Error as BERError, decode, encode},
-    de::Needed,
+    ber::{decode, encode},
     types::{Any, BitString, Class, OctetString, PrintableString},
     Decode, Tag,
 };
@@ -18,7 +17,7 @@ use crate::{
         ASN1BitString, ASN1Context, ASN1ContextTag, ASN1Object, ASN1RawBitString, ASN1Set, ASN1OID,
     },
     types::{ASN1Data, JsType},
-    utils::{get_utc_date_time_from_asn1_milli, get_vec_from_js_unknown, repair_bit_string_data},
+    utils::{get_utc_date_time_from_asn1_milli, get_vec_from_js_unknown},
     ASN1NAPIError,
 };
 
@@ -76,18 +75,10 @@ impl ASN1Encoder {
     }
 
     /// Encode ASN1Data to a Vec<u8> of ASN.1 encoded data.
-    /// TODO Mising bits that the rasn library truncates.
     pub(crate) fn encode(&self) -> Result<Vec<u8>> {
-        if let Ok(mut data) = encode(&self.0) {
-            match &self.0 {
-                ASN1Data::Object(ASN1Object::BitString(val)) => {
-                    repair_bit_string_data(&mut data, val.clone().into_vec(), true);
-                    Ok(data)
-                }
-                _ => Ok(data),
-            }
-        } else {
-            bail!(ASN1NAPIError::MalformedData)
+        match encode(&self.0) {
+            Ok(data) => Ok(data),
+            Err(_) => bail!(ASN1NAPIError::InvalidDataEncoding),
         }
     }
 
@@ -162,58 +153,32 @@ impl ASN1Decoder {
     /// Create an instance of ANS1 from Base64 encoded data.
     #[napi]
     pub fn from_base64(value: String) -> Result<ASN1Decoder> {
-        if let Ok(result) = base64::decode(value) {
-            Self::try_from(result.as_slice())
-        } else {
-            bail!(ASN1NAPIError::UnknownStringFormat)
+        match base64::decode(value) {
+            Ok(result) => Self::try_from(result.as_slice()),
+            Err(_) => bail!(ASN1NAPIError::UnknownStringFormat),
         }
     }
 
     /// Create an instance of ANS1 from hex encoded data.
     #[napi]
     pub fn from_hex(value: String) -> Result<ASN1Decoder> {
-        if let Ok(result) = hex::decode(value) {
-            Self::try_from(result.as_slice())
-        } else {
-            bail!(ASN1NAPIError::UnknownStringFormat)
+        match hex::decode(value) {
+            Ok(result) => Self::try_from(result.as_slice()),
+            Err(_) => bail!(ASN1NAPIError::UnknownStringFormat),
         }
     }
 
     /// Decode ASN1 encoded data.
-    /// TODO Mising bits that the rasn library truncates.
     pub(crate) fn decode<T: Decode>(&self) -> Result<T> {
         match decode(&self.data) {
             Ok(data) => Ok(data),
-            Err(err) => match err {
-                BERError::Incomplete {
-                    needed: Needed::Size(val),
-                } => {
-                    let data = [..val].iter().fold(self.data.clone(), |mut data, _| {
-                        data.push(0x00);
-                        data
-                    });
-                    if let Ok(result) = decode(&data) {
-                        Ok(result)
-                    } else {
-                        bail!(ASN1NAPIError::InvalidBitString)
-                    }
-                }
-                _ => bail!(ASN1NAPIError::MalformedData),
-            },
+            Err(_) => bail!(ASN1NAPIError::MalformedData),
         }
     }
 
     /// Get a ASN1BitString object.
     pub(crate) fn get_raw_bit_string(&self) -> Result<ASN1RawBitString> {
-        if let Ok(result) = self.decode::<ASN1RawBitString>() {
-            let mut data = result.into_vec();
-
-            repair_bit_string_data(&mut data, self.data.clone(), false);
-
-            Ok(ASN1RawBitString::new(BitString::from_vec(data)))
-        } else {
-            bail!(ASN1NAPIError::InvalidBitString)
-        }
+        self.decode::<ASN1RawBitString>()
     }
 
     /// Get a Context object.
@@ -227,12 +192,8 @@ impl ASN1Decoder {
     }
 
     /// Decode an object to an ASN1Object.
-    /// TODO Mising bits that the rasn library truncates.
     pub(crate) fn into_object(self) -> Result<ASN1Object> {
-        match self.get_tag() {
-            &Tag::BIT_STRING => Ok(ASN1Object::BitString(self.get_raw_bit_string()?)),
-            _ => self.decode::<ASN1Object>(),
-        }
+        self.decode::<ASN1Object>()
     }
 
     /// Convert to a big integer.

src/lib.rs

@@ -54,6 +54,8 @@ enum ASN1NAPIError {
     InvalidSimpleTypesOnly,
     #[error("Context data must be a sequence")]
     InvalidContextNonSequence,
+    #[error("Could not encode provided data into ASN.1 format")]
+    InvalidDataEncoding,
 }
 
 /// Helper to convert a JS bigint to a JS Buffer

src/objects.rs

@@ -1,3 +1,5 @@
+use std::collections::VecDeque;
+
 use anyhow::{bail, Error, Result};
 use napi::{Env, JsBuffer, JsNumber, JsObject, JsString, JsUnknown, ValueType};
 use rasn::{
@@ -164,10 +166,16 @@ pub trait TypedObject<'a> {
 
 impl ASN1RawBitString {
     pub fn new(mut value: BitString) -> Self {
+        value.force_align();
         value.set_uninitialized(false);
+
         Self(value)
     }
 
+    pub fn get_unused(&self) -> usize {
+        self.0.trailing_zeros()
+    }
+
     pub fn into_vec(self) -> Vec<u8> {
         self.0.into_vec()
     }
@@ -231,16 +239,29 @@ type_object!(ASN1OID, "oid");
 type_object!(ASN1Set, "set");
 type_object!(ASN1ContextTag, "context");
 
+/// TODO Mising bits that the rasn library truncates.
 impl Encode for ASN1RawBitString {
     fn encode_with_tag<E: Encoder>(&self, encoder: &mut E, tag: Tag) -> Result<(), E::Error> {
-        encoder.encode_bit_string(tag, &self.0)?;
+        let mut data = VecDeque::from(self.0.clone().into_vec());
+        data.push_front(0x00);
+
+        encoder.encode_octet_string(tag, &Vec::from(data))?;
         Ok(())
     }
 }
 
+/// TODO Mising bits that the rasn library truncates.
 impl Decode for ASN1RawBitString {
     fn decode_with_tag<D: Decoder>(decoder: &mut D, tag: Tag) -> Result<Self, D::Error> {
-        Ok(ASN1RawBitString::new(decoder.decode_bit_string(tag)?))
+        let mut data = VecDeque::from(decoder.decode_octet_string(tag)?);
+
+        if let Some(val) = data.get(0) {
+            if val == &0x00 {
+                data.pop_front();
+            }
+        }
+
+        Ok(ASN1RawBitString::new(BitString::from_vec(Vec::from(data))))
     }
 }
 

src/utils.rs

@@ -134,24 +134,6 @@ pub(crate) fn get_vec_from_js_unknown(data: JsUnknown) -> Result<Vec<u8>> {
     })
 }
 
-/// Fixes discrepencies between asn1js and rasn regarding bit strings.
-/// TODO Mising bits that the rasn library truncates.
-pub(crate) fn repair_bit_string_data(data: &mut Vec<u8>, mut reference: Vec<u8>, incr_len: bool) {
-    while let Some(val) = reference.pop() {
-        if val == 0x00 {
-            if let Some(pos) = data.get(1) {
-                if incr_len {
-                    data[1] = pos + 1;
-                }
-
-                data.push(0x00);
-            }
-        } else {
-            break;
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use chrono::{TimeZone, Utc};

tests/object.bitstring.spec.ts

@@ -17,6 +17,13 @@ const TEST_BITSTRINGS: lib.ASN1BitString[] = [
       'base64',
     ),
   },
+  {
+    type: 'bitstring',
+    value: Buffer.from(
+      'MEQCIHd0xqmKNBV76Rqp65DJjZMoWsv6Z5THAtyNqkKeYX6pAiAwWqVPgu7W8WIQHOI6JIDsfve1xPskMUIgu56TFFqitA==',
+      'base64',
+    ),
+  },
 ]
 
 const TEST_BITSTRINGS_ASN1 = [
@@ -38,6 +45,15 @@ const TEST_BITSTRINGS_ASN1 = [
     0x65, 0xd4, 0x2c, 0xcf, 0xec, 0x2a, 0x6a, 0x30, 0xad, 0x47, 0xe1, 0x7e,
     0x00,
   ]).buffer,
+  new Uint8Array([
+    0x03, 0x47, 0x00, 0x30, 0x44, 0x02, 0x20, 0x77, 0x74, 0xc6, 0xa9, 0x8a,
+    0x34, 0x15, 0x7b, 0xe9, 0x1a, 0xa9, 0xeb, 0x90, 0xc9, 0x8d, 0x93, 0x28,
+    0x5a, 0xcb, 0xfa, 0x67, 0x94, 0xc7, 0x02, 0xdc, 0x8d, 0xaa, 0x42, 0x9e,
+    0x61, 0x7e, 0xa9, 0x02, 0x20, 0x30, 0x5a, 0xa5, 0x4f, 0x82, 0xee, 0xd6,
+    0xf1, 0x62, 0x10, 0x1c, 0xe2, 0x3a, 0x24, 0x80, 0xec, 0x7e, 0xf7, 0xb5,
+    0xc4, 0xfb, 0x24, 0x31, 0x42, 0x20, 0xbb, 0x9e, 0x93, 0x14, 0x5a, 0xa2,
+    0xb4,
+  ]).buffer,
 ]
 
 test('JS ASN1BitString to ASN1 conversion', (t) => {