From b8766a2041d57a3aa49c3855902953f8de0b0ec1 Mon Sep 17 00:00:00 2001 From: Christian Pointner Date: Sat, 23 Feb 2008 23:05:43 +0000 Subject: - keyderivation and cipher should work now however it needs further testing - rewrite of Buffer and Packets --- encryptedPacket.cpp | 168 ++++++++++++++++++++++++++++------------------------ 1 file changed, 89 insertions(+), 79 deletions(-) (limited to 'encryptedPacket.cpp') diff --git a/encryptedPacket.cpp b/encryptedPacket.cpp index 0731d24..a3e5886 100644 --- a/encryptedPacket.cpp +++ b/encryptedPacket.cpp @@ -38,139 +38,149 @@ #include "authTag.h" #include "log.h" - -EncryptedPacket::EncryptedPacket(u_int32_t max_payload_length) - : Buffer(max_payload_length + sizeof(struct HeaderStruct) + AUTHTAG_SIZE) +// TODO: fix auth_tag stuff +EncryptedPacket::EncryptedPacket(u_int32_t payload_length, bool allow_realloc) + : Buffer(payload_length + sizeof(struct HeaderStruct), allow_realloc) { header_ = reinterpret_cast(buf_); - auth_tag_ = NULL; - payload_ = buf_ + sizeof(struct HeaderStruct); // no authtag yet - length_ = sizeof(struct HeaderStruct); - max_length_ = max_payload_length + AUTHTAG_SIZE; -} - - -EncryptedPacket::~EncryptedPacket() -{ - buf_ = reinterpret_cast(header_); - if( auth_tag_ == NULL ) - length_ = max_length_ + sizeof(struct HeaderStruct) + AUTHTAG_SIZE; - else - length_ = max_length_ + sizeof(struct HeaderStruct); -} - -void EncryptedPacket::setPayloadLength(u_int32_t payload_length) -{ - if( auth_tag_) - length_= payload_length + sizeof(struct HeaderStruct)+AUTHTAG_SIZE; - else - length_= payload_length + sizeof(struct HeaderStruct); + payload_ = buf_ + sizeof(struct HeaderStruct); // TODO: fix auth_tag stuff + auth_tag_ = NULL; // TODO: fix auth_tag stuff + if(header_) + { + header_->seq_nr = 0; + header_->sender_id = 0; + header_->mux = 0; + } } seq_nr_t EncryptedPacket::getSeqNr() const { - return SEQ_NR_T_NTOH(header_->seq_nr); + if(header_) + return SEQ_NR_T_NTOH(header_->seq_nr); + + return 0; } sender_id_t EncryptedPacket::getSenderId() const { - return SENDER_ID_T_NTOH(header_->sender_id); -} + if(header_) + return SENDER_ID_T_NTOH(header_->sender_id); -mux_t EncryptedPacket::getMux() const -{ - return MUX_T_NTOH(header_->mux); + return 0; } -u_int32_t EncryptedPacket::getMaxLength() const +mux_t EncryptedPacket::getMux() const { - return max_length_; -} + if(header_) + return MUX_T_NTOH(header_->mux); -void EncryptedPacket::setLength(u_int32_t length) -{ - if(length > max_length_) - throw std::out_of_range("can't set length greater then size ofsize of allocated memory"); - - length_ = length; - if( auth_tag_) - payload_length_ = length_ - sizeof(struct HeaderStruct)+AUTHTAG_SIZE; - else - payload_length_ = length_ - sizeof(struct HeaderStruct); + return 0; } void EncryptedPacket::setSeqNr(seq_nr_t seq_nr) { - header_->seq_nr = SEQ_NR_T_HTON(seq_nr); + if(header_) + header_->seq_nr = SEQ_NR_T_HTON(seq_nr); } void EncryptedPacket::setSenderId(sender_id_t sender_id) { - header_->sender_id = SENDER_ID_T_HTON(sender_id); + if(header_) + header_->sender_id = SENDER_ID_T_HTON(sender_id); } void EncryptedPacket::setMux(mux_t mux) { - header_->mux = MUX_T_HTON(mux); + if(header_) + header_->mux = MUX_T_HTON(mux); } void EncryptedPacket::setHeader(seq_nr_t seq_nr, sender_id_t sender_id, mux_t mux) { + if(!header_) + return; + header_->seq_nr = SEQ_NR_T_HTON(seq_nr); header_->sender_id = SENDER_ID_T_HTON(sender_id); header_->mux = MUX_T_HTON(mux); } +u_int32_t EncryptedPacket::getPayloadLength() const +{ + return (length_ > sizeof(struct HeaderStruct)) ? (length_ - sizeof(struct HeaderStruct)) : 0; // TODO: fix auth_tag stuff +} + +void EncryptedPacket::setPayloadLength(u_int32_t payload_length) +{ + Buffer::setLength(payload_length + sizeof(struct HeaderStruct)); + + // depending on allow_realloc buf_ may point to another address + header_ = reinterpret_cast(buf_); + payload_ = buf_ + sizeof(struct HeaderStruct); // TODO: fix auth_tag stuff + auth_tag_ = NULL; // TODO: fix auth_tag stuff +} + +u_int8_t* EncryptedPacket::getPayload() +{ + return payload_; +} + + + + + + +// TODO: fix auth_tag stuff + bool EncryptedPacket::hasAuthTag() const { - if( auth_tag_ == NULL ) - return false; - return true; +// if( auth_tag_ == NULL ) + return false; +// return true; } void EncryptedPacket::withAuthTag(bool b) { - if( b && (auth_tag_ != NULL) ) - throw std::runtime_error("packet already has auth tag function enabled"); - //TODO: return instead? - if( ! b && (auth_tag_ == NULL) ) - throw std::runtime_error("packet already has auth tag function disabled"); - //TODO: return instead? - - if( b ) { - auth_tag_ = reinterpret_cast( buf_ + sizeof(struct HeaderStruct) ); - payload_ = payload_ + AUTHTAG_SIZE; - length_ -= AUTHTAG_SIZE; - max_length_ -= AUTHTAG_SIZE; - } else { - payload_ = reinterpret_cast( auth_tag_ ); - length_ += AUTHTAG_SIZE; - max_length_ += AUTHTAG_SIZE; - auth_tag_ = NULL; - } +// if( b && (auth_tag_ != NULL) ) +// throw std::runtime_error("packet already has auth tag function enabled"); +// //TODO: return instead? +// if( ! b && (auth_tag_ == NULL) ) +// throw std::runtime_error("packet already has auth tag function disabled"); +// //TODO: return instead? + +// if( b ) { +// auth_tag_ = reinterpret_cast( buf_ + sizeof(struct HeaderStruct) ); +// payload_ = payload_ + AUTHTAG_SIZE; +// length_ -= AUTHTAG_SIZE; +// max_length_ -= AUTHTAG_SIZE; +// } else { +// payload_ = reinterpret_cast( auth_tag_ ); +// length_ += AUTHTAG_SIZE; +// max_length_ += AUTHTAG_SIZE; +// auth_tag_ = NULL; +// } } void EncryptedPacket::setAuthTag(AuthTag& tag) { - if( auth_tag_ == NULL ) - throw std::runtime_error("auth tag not enabled"); +// if( auth_tag_ == NULL ) +// throw std::runtime_error("auth tag not enabled"); - if( tag == AuthTag(0) ) - return; +// if( tag == AuthTag(0) ) +// return; - if( tag.getLength() != AUTHTAG_SIZE ) - throw std::length_error("authtag length mismatch with AUTHTAG_SIZE"); +// if( tag.getLength() != AUTHTAG_SIZE ) +// throw std::length_error("authtag length mismatch with AUTHTAG_SIZE"); - std::memcpy( auth_tag_, tag.getBuf(), AUTHTAG_SIZE ); +// std::memcpy( auth_tag_, tag.getBuf(), AUTHTAG_SIZE ); } AuthTag EncryptedPacket::getAuthTag() const { - if( auth_tag_ == NULL ) - throw std::runtime_error("auth tag not enabled"); +// if( auth_tag_ == NULL ) +// throw std::runtime_error("auth tag not enabled"); AuthTag at(AUTHTAG_SIZE); - std::memcpy(at, auth_tag_, AUTHTAG_SIZE ); +// std::memcpy(at, auth_tag_, AUTHTAG_SIZE ); return at; } - -- cgit v1.2.3