// asn.cpp - originally written and placed in the public domain by Wei Dai

//           CryptoPP::Test namespace added by JW in February 2017

#include "pch.h"

#include "config.h"

#ifndef CRYPTOPP_IMPORTS

#include "cryptlib.h"

#include "asn.h"

#include "misc.h"

#include <iostream>

#include <iomanip>

#include <sstream>

#include <time.h>

NAMESPACE_BEGIN(CryptoPP)

size_t DERLengthEncode(BufferedTransformation &bt, lword length)

{

  size_t i=0;

  if (length <= 0x7f)

  {

    bt.Put(byte(length));

    i++;

  }

  else

  {

    bt.Put(byte(BytePrecision(length) | 0x80));

    i++;

    for (int j=BytePrecision(length); j; --j)

    {

      bt.Put(byte(length >> (j-1)*8));

      i++;

    }

  }

  return i;

}

bool BERLengthDecode(BufferedTransformation &bt, lword &length, bool &definiteLength)

{

  byte b;

  if (!bt.Get(b))

    return false;

  if (!(b & 0x80))

  {

    definiteLength = true;

    length = b;

  }

  else

  {

    unsigned int lengthBytes = b & 0x7f;

    if (lengthBytes == 0)

    {

      definiteLength = false;

      return true;

    }

    definiteLength = true;

    length = 0;

    while (lengthBytes--)

    {

      if (length >> (8*(sizeof(length)-1)))

        BERDecodeError(); // length about to overflow

      if (!bt.Get(b))

        return false;

      length = (length << 8) | b;

    }

  }

  return true;

}

bool BERLengthDecode(BufferedTransformation &bt, size_t &length)

{

  lword lw = 0;

  bool definiteLength = false;

  if (!BERLengthDecode(bt, lw, definiteLength))

    BERDecodeError();

  if (!SafeConvert(lw, length))

    BERDecodeError();

  return definiteLength;

}

void DEREncodeNull(BufferedTransformation &out)

{

  out.Put(TAG_NULL);

  out.Put(0);

}

void BERDecodeNull(BufferedTransformation &in)

{

  byte b;

  if (!in.Get(b) || b != TAG_NULL)

    BERDecodeError();

  size_t length;

  if (!BERLengthDecode(in, length) || length != 0)

    BERDecodeError();

}

/// ASN Strings

size_t DEREncodeOctetString(BufferedTransformation &bt, const byte *str, size_t strLen)

{

  bt.Put(OCTET_STRING);

  size_t lengthBytes = DERLengthEncode(bt, strLen);

  bt.Put(str, strLen);

  return 1+lengthBytes+strLen;

}

size_t DEREncodeOctetString(BufferedTransformation &bt, const SecByteBlock &str)

{

  return DEREncodeOctetString(bt, ConstBytePtr(str), BytePtrSize(str));

}

size_t BERDecodeOctetString(BufferedTransformation &bt, SecByteBlock &str)

{

  byte b;

  if (!bt.Get(b) || b != OCTET_STRING)

    BERDecodeError();

  size_t bc;

  if (!BERLengthDecode(bt, bc))

    BERDecodeError();

  if (bc > bt.MaxRetrievable()) // Issue 346

    BERDecodeError();

  str.New(bc);

  if (bc != bt.Get(BytePtr(str), bc))

    BERDecodeError();

  return bc;

}

size_t BERDecodeOctetString(BufferedTransformation &bt, BufferedTransformation &str)

{

  byte b;

  if (!bt.Get(b) || b != OCTET_STRING)

    BERDecodeError();

  size_t bc;

  if (!BERLengthDecode(bt, bc))

    BERDecodeError();

  if (bc > bt.MaxRetrievable()) // Issue 346

    BERDecodeError();

  bt.TransferTo(str, bc);

  return bc;

}

size_t DEREncodeTextString(BufferedTransformation &bt, const byte* str, size_t strLen, byte asnTag)

{

  bt.Put(asnTag);

  size_t lengthBytes = DERLengthEncode(bt, strLen);

  bt.Put(str, strLen);

  return 1+lengthBytes+strLen;

}

size_t DEREncodeTextString(BufferedTransformation &bt, const SecByteBlock &str, byte asnTag)

{

  return DEREncodeTextString(bt, ConstBytePtr(str), BytePtrSize(str), asnTag);

}

size_t DEREncodeTextString(BufferedTransformation &bt, const std::string &str, byte asnTag)

{

  return DEREncodeTextString(bt, ConstBytePtr(str), BytePtrSize(str), asnTag);

}

size_t BERDecodeTextString(BufferedTransformation &bt, SecByteBlock &str, byte asnTag)

{

  byte b;

  if (!bt.Get(b) || b != asnTag)

    BERDecodeError();

  size_t bc;

  if (!BERLengthDecode(bt, bc))

    BERDecodeError();

  if (bc > bt.MaxRetrievable()) // Issue 346

    BERDecodeError();

  str.resize(bc);

  if (bc != bt.Get(BytePtr(str), BytePtrSize(str)))

    BERDecodeError();

  return bc;

}

size_t BERDecodeTextString(BufferedTransformation &bt, std::string &str, byte asnTag)

{

  byte b;

  if (!bt.Get(b) || b != asnTag)

    BERDecodeError();

  size_t bc;

  if (!BERLengthDecode(bt, bc))

    BERDecodeError();

  if (bc > bt.MaxRetrievable()) // Issue 346

    BERDecodeError();

  str.resize(bc);

  if (bc != bt.Get(BytePtr(str), BytePtrSize(str)))

    BERDecodeError();

  return bc;

}

size_t DEREncodeDate(BufferedTransformation &bt, const SecByteBlock &str, byte asnTag)

{

  bt.Put(asnTag);

  size_t lengthBytes = DERLengthEncode(bt, str.size());

  bt.Put(ConstBytePtr(str), BytePtrSize(str));

  return 1+lengthBytes+str.size();

}

size_t BERDecodeDate(BufferedTransformation &bt, SecByteBlock &str, byte asnTag)

{

  byte b;

  if (!bt.Get(b) || b != asnTag)

    BERDecodeError();

  size_t bc;

  if (!BERLengthDecode(bt, bc))

    BERDecodeError();

  if (bc > bt.MaxRetrievable()) // Issue 346

    BERDecodeError();

  str.resize(bc);

  if (bc != bt.Get(BytePtr(str), BytePtrSize(str)))

    BERDecodeError();

  return bc;

}

size_t DEREncodeBitString(BufferedTransformation &bt, const byte *str, size_t strLen, unsigned int unusedBits)

{

  bt.Put(BIT_STRING);

  size_t lengthBytes = DERLengthEncode(bt, strLen+1);

  bt.Put((byte)unusedBits);

  bt.Put(str, strLen);

  return 2+lengthBytes+strLen;

}

size_t BERDecodeBitString(BufferedTransformation &bt, SecByteBlock &str, unsigned int &unusedBits)

{

  byte b;

  if (!bt.Get(b) || b != BIT_STRING)

    BERDecodeError();

  size_t bc;

  if (!BERLengthDecode(bt, bc))

    BERDecodeError();

  if (bc == 0)

    BERDecodeError();

  if (bc > bt.MaxRetrievable()) // Issue 346

    BERDecodeError();

  // X.690, 8.6.2.2: "The number [of unused bits] shall be in the range zero to seven"

  byte unused;

  if (!bt.Get(unused) || unused > 7)

    BERDecodeError();

  unusedBits = unused;

  str.resize(bc-1);

  if ((bc-1) != bt.Get(BytePtr(str), bc-1))

    BERDecodeError();

  return bc-1;

}

void DERReencode(BufferedTransformation &source, BufferedTransformation &dest)

{

  byte tag;

  source.Peek(tag);

  BERGeneralDecoder decoder(source, tag);

  DERGeneralEncoder encoder(dest, tag);

  if (decoder.IsDefiniteLength())

    decoder.TransferTo(encoder, decoder.RemainingLength());

  else

  {

    while (!decoder.EndReached())

      DERReencode(decoder, encoder);

  }

  decoder.MessageEnd();

  encoder.MessageEnd();

}

size_t BERDecodePeekLength(const BufferedTransformation &bt)

{

  lword count = (std::min)(bt.MaxRetrievable(), static_cast<lword>(16));

  if (count == 0) return 0;

  ByteQueue tagAndLength;

  bt.CopyTo(tagAndLength, count);

  // Skip tag

  tagAndLength.Skip(1);

  // BERLengthDecode fails for indefinite length.

  size_t length;

  if (!BERLengthDecode(tagAndLength, length))

    return 0;

  return length;

}

void OID::EncodeValue(BufferedTransformation &bt, word32 v)

{

  for (unsigned int i=RoundUpToMultipleOf(STDMAX(7U,BitPrecision(v)), 7U)-7; i != 0; i-=7)

    bt.Put((byte)(0x80 | ((v >> i) & 0x7f)));

  bt.Put((byte)(v & 0x7f));

}

size_t OID::DecodeValue(BufferedTransformation &bt, word32 &v)

{

  byte b;

  size_t i=0;

  v = 0;

  while (true)

  {

    if (!bt.Get(b))

      BERDecodeError();

    i++;

    if (v >> (8*sizeof(v)-7)) // v about to overflow

      BERDecodeError();

    v <<= 7;

    v += b & 0x7f;

    if (!(b & 0x80))

      return i;

  }

}

void OID::DEREncode(BufferedTransformation &bt) const

{

  CRYPTOPP_ASSERT(m_values.size() >= 2);

  ByteQueue temp;

  temp.Put(byte(m_values[0] * 40 + m_values[1]));

  for (size_t i=2; i<m_values.size(); i++)

    EncodeValue(temp, m_values[i]);

  bt.Put(OBJECT_IDENTIFIER);

  DERLengthEncode(bt, temp.CurrentSize());

  temp.TransferTo(bt);

}

void OID::BERDecode(BufferedTransformation &bt)

{

  byte b;

  if (!bt.Get(b) || b != OBJECT_IDENTIFIER)

    BERDecodeError();

  size_t length;

  if (!BERLengthDecode(bt, length) || length < 1)

    BERDecodeError();

  if (!bt.Get(b))

    BERDecodeError();

  length--;

  m_values.resize(2);

  m_values[0] = b / 40;

  m_values[1] = b % 40;

  while (length > 0)

  {

    word32 v;

    size_t valueLen = DecodeValue(bt, v);

    if (valueLen > length)

      BERDecodeError();

    m_values.push_back(v);

    length -= valueLen;

  }

}

void OID::BERDecodeAndCheck(BufferedTransformation &bt) const

{

  OID oid(bt);

  if (*this != oid)

    BERDecodeError();

}

std::ostream& OID::Print(std::ostream& out) const

{

  std::ostringstream oss;

  for (size_t i = 0; i < m_values.size(); ++i)

  {

    oss << m_values[i];

    if (i+1 < m_values.size())

      oss << ".";

  }

  return out << oss.str();

}

inline BufferedTransformation & EncodedObjectFilter::CurrentTarget()

{

  if (m_flags & PUT_OBJECTS)

    return *AttachedTransformation();

  else

    return TheBitBucket();

}

void EncodedObjectFilter::Put(const byte *inString, size_t length)

{

  if (m_nCurrentObject == m_nObjects)

  {

    AttachedTransformation()->Put(inString, length);

    return;

  }

  LazyPutter lazyPutter(m_queue, inString, length);

  while (m_queue.AnyRetrievable())

  {

    switch (m_state)

    {

    case IDENTIFIER:

      if (!m_queue.Get(m_id))

        return;

      m_queue.TransferTo(CurrentTarget(), 1);

      m_state = LENGTH;

    // fall through

    case LENGTH:

    {

      byte b;

      if (m_level > 0 && m_id == 0 && m_queue.Peek(b) && b == 0)

      {

        m_queue.TransferTo(CurrentTarget(), 1);

        m_level--;

        m_state = IDENTIFIER;

        break;

      }

      ByteQueue::Walker walker(m_queue);

      bool definiteLength = false;

      if (!BERLengthDecode(walker, m_lengthRemaining, definiteLength))

        return;

      m_queue.TransferTo(CurrentTarget(), walker.GetCurrentPosition());

      if (!((m_id & CONSTRUCTED) || definiteLength))

        BERDecodeError();

      if (!definiteLength)

      {

        if (!(m_id & CONSTRUCTED))

          BERDecodeError();

        m_level++;

        m_state = IDENTIFIER;

        break;

      }

      m_state = BODY;

    }

    // fall through

    case BODY:

      m_lengthRemaining -= m_queue.TransferTo(CurrentTarget(), m_lengthRemaining);

      if (m_lengthRemaining == 0)

        m_state = IDENTIFIER;

    // fall through

    case TAIL:

    case ALL_DONE:

    default: ;

    }

    if (m_state == IDENTIFIER && m_level == 0)

    {

      // just finished processing a level 0 object

      ++m_nCurrentObject;

      if (m_flags & PUT_MESSANGE_END_AFTER_EACH_OBJECT)

        AttachedTransformation()->MessageEnd();

      if (m_nCurrentObject == m_nObjects)

      {

        if (m_flags & PUT_MESSANGE_END_AFTER_ALL_OBJECTS)

          AttachedTransformation()->MessageEnd();

        if (m_flags & PUT_MESSANGE_SERIES_END_AFTER_ALL_OBJECTS)

          AttachedTransformation()->MessageSeriesEnd();

        m_queue.TransferAllTo(*AttachedTransformation());

        return;

      }

    }

  }

}

BERGeneralDecoder::BERGeneralDecoder(BufferedTransformation &inQueue)

  : m_inQueue(inQueue), m_length(0), m_finished(false)

{

  Init(DefaultTag);

}

BERGeneralDecoder::BERGeneralDecoder(BufferedTransformation &inQueue, byte asnTag)

  : m_inQueue(inQueue), m_length(0), m_finished(false)

{

  Init(asnTag);

}

BERGeneralDecoder::BERGeneralDecoder(BERGeneralDecoder &inQueue, byte asnTag)

  : m_inQueue(inQueue), m_length(0), m_finished(false)

{

  Init(asnTag);

}

void BERGeneralDecoder::Init(byte asnTag)

{

  byte b;

  if (!m_inQueue.Get(b) || b != asnTag)

    BERDecodeError();

  if (!BERLengthDecode(m_inQueue, m_length, m_definiteLength))

    BERDecodeError();

  if (!m_definiteLength && !(asnTag & CONSTRUCTED))

    BERDecodeError(); // cannot be primitive and have indefinite length

}

BERGeneralDecoder::~BERGeneralDecoder()

{

  try // avoid throwing in destructor

  {

    if (!m_finished)

      MessageEnd();

  }

  catch (const Exception&)

  {

    // CRYPTOPP_ASSERT(0);

  }

}

bool BERGeneralDecoder::EndReached() const

{

  if (m_definiteLength)

    return m_length == 0;

  else

  { // check end-of-content octets

    word16 i;

    return (m_inQueue.PeekWord16(i)==2 && i==0);

  }

}

byte BERGeneralDecoder::PeekByte() const

{

  byte b;

  if (!Peek(b))

    BERDecodeError();

  return b;

}

void BERGeneralDecoder::CheckByte(byte check)

{

  byte b;

  if (!Get(b) || b != check)

    BERDecodeError();

}

void BERGeneralDecoder::MessageEnd()

{

  m_finished = true;

  if (m_definiteLength)

  {

    if (m_length != 0)

      BERDecodeError();

  }

  else

  { // remove end-of-content octets

    word16 i;

    if (m_inQueue.GetWord16(i) != 2 || i != 0)

      BERDecodeError();

  }

}

size_t BERGeneralDecoder::TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel, bool blocking)

{

  if (m_definiteLength && transferBytes > m_length)

    transferBytes = m_length;

  size_t blockedBytes = m_inQueue.TransferTo2(target, transferBytes, channel, blocking);

  ReduceLength(transferBytes);

  return blockedBytes;

}

size_t BERGeneralDecoder::CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end, const std::string &channel, bool blocking) const

{

  if (m_definiteLength)

    end = STDMIN(m_length, end);

  return m_inQueue.CopyRangeTo2(target, begin, end, channel, blocking);

}

lword BERGeneralDecoder::ReduceLength(lword delta)

{

  if (m_definiteLength)

  {

    if (m_length < delta)

      BERDecodeError();

    m_length -= delta;

  }

  return delta;

}

DERGeneralEncoder::DERGeneralEncoder(BufferedTransformation &outQueue)

  : m_outQueue(outQueue), m_asnTag(DefaultTag), m_finished(false)

{

}

DERGeneralEncoder::DERGeneralEncoder(BufferedTransformation &outQueue, byte asnTag)

  : m_outQueue(outQueue), m_asnTag(asnTag), m_finished(false)

{

}

DERGeneralEncoder::DERGeneralEncoder(DERGeneralEncoder &outQueue, byte asnTag)

  : m_outQueue(outQueue), m_asnTag(asnTag), m_finished(false)

{

}

DERGeneralEncoder::~DERGeneralEncoder()

{

  try // avoid throwing in constructor

  {

    if (!m_finished)

      MessageEnd();

  }

  catch (const Exception&)

  {

    CRYPTOPP_ASSERT(0);

  }

}

void DERGeneralEncoder::MessageEnd()

{

  m_finished = true;

  lword length = CurrentSize();

  m_outQueue.Put(m_asnTag);

  DERLengthEncode(m_outQueue, length);

  TransferTo(m_outQueue);

}

// *************************************************************

void X509PublicKey::BERDecode(BufferedTransformation &bt)

{

  BERSequenceDecoder subjectPublicKeyInfo(bt);

    BERSequenceDecoder algorithm(subjectPublicKeyInfo);

      GetAlgorithmID().BERDecodeAndCheck(algorithm);

      bool parametersPresent = algorithm.EndReached() ? false : BERDecodeAlgorithmParameters(algorithm);

    algorithm.MessageEnd();

    BERGeneralDecoder subjectPublicKey(subjectPublicKeyInfo, BIT_STRING);

      subjectPublicKey.CheckByte(0);  // unused bits

      BERDecodePublicKey(subjectPublicKey, parametersPresent, (size_t)subjectPublicKey.RemainingLength());

    subjectPublicKey.MessageEnd();

  subjectPublicKeyInfo.MessageEnd();

}

void X509PublicKey::DEREncode(BufferedTransformation &bt) const

{

  DERSequenceEncoder subjectPublicKeyInfo(bt);

    DERSequenceEncoder algorithm(subjectPublicKeyInfo);

      GetAlgorithmID().DEREncode(algorithm);

      DEREncodeAlgorithmParameters(algorithm);

    algorithm.MessageEnd();

    DERGeneralEncoder subjectPublicKey(subjectPublicKeyInfo, BIT_STRING);

      subjectPublicKey.Put(0);  // unused bits

      DEREncodePublicKey(subjectPublicKey);

    subjectPublicKey.MessageEnd();

  subjectPublicKeyInfo.MessageEnd();

}

void PKCS8PrivateKey::BERDecode(BufferedTransformation &bt)

{

  BERSequenceDecoder privateKeyInfo(bt);

    word32 version;

    BERDecodeUnsigned<word32>(privateKeyInfo, version, INTEGER, 0, 0);  // check version

    BERSequenceDecoder algorithm(privateKeyInfo);

      GetAlgorithmID().BERDecodeAndCheck(algorithm);

      bool parametersPresent = algorithm.EndReached() ? false : BERDecodeAlgorithmParameters(algorithm);

    algorithm.MessageEnd();

    BERGeneralDecoder octetString(privateKeyInfo, OCTET_STRING);

      BERDecodePrivateKey(octetString, parametersPresent, (size_t)privateKeyInfo.RemainingLength());

    octetString.MessageEnd();

    if (!privateKeyInfo.EndReached())

      BERDecodeOptionalAttributes(privateKeyInfo);

  privateKeyInfo.MessageEnd();

}

void PKCS8PrivateKey::DEREncode(BufferedTransformation &bt) const

{

  DERSequenceEncoder privateKeyInfo(bt);

    DEREncodeUnsigned<word32>(privateKeyInfo, 0); // version

    DERSequenceEncoder algorithm(privateKeyInfo);

      GetAlgorithmID().DEREncode(algorithm);

      DEREncodeAlgorithmParameters(algorithm);

    algorithm.MessageEnd();

    DERGeneralEncoder octetString(privateKeyInfo, OCTET_STRING);

      DEREncodePrivateKey(octetString);

    octetString.MessageEnd();

    DEREncodeOptionalAttributes(privateKeyInfo);

  privateKeyInfo.MessageEnd();

}

void PKCS8PrivateKey::BERDecodeOptionalAttributes(BufferedTransformation &bt)

{

  DERReencode(bt, m_optionalAttributes);

}

void PKCS8PrivateKey::DEREncodeOptionalAttributes(BufferedTransformation &bt) const

{

  m_optionalAttributes.CopyTo(bt);

}

NAMESPACE_END

#endif