use serialize::hex::{ ToHex };
use self::PacketType::{ Command, Answer, Error };
use crypto;
use serialize::hex::{ ToHex };
use self::PacketType::{ Command, Answer, Error };
use crypto;
pub enum Variant {
Weak, // The MAC is computed on data without padding.
Fixed // The MAC is computed on data and padding.
}
// There are all the errors that may occur when reading an encrypted and authenticated packet.
pub enum Variant {
Weak, // The MAC is computed on data without padding.
Fixed // The MAC is computed on data and padding.
}
// There are all the errors that may occur when reading an encrypted and authenticated packet.
static MAX_PAYLOAD_SIZE: uint = 39;
static FIXED_PACKET_SIZE: uint = 1 + 8 + 10; // Packet type + timestamp + MAC.
static MAX_PAYLOAD_SIZE: uint = 39;
static FIXED_PACKET_SIZE: uint = 1 + 8 + 10; // Packet type + timestamp + MAC.
/// |I|C...C| for weak variant
/// |I|C...C|P...P|for fixed variant
/// |0000000000000000| for error packet
/// |I|C...C| for weak variant
/// |I|C...C|P...P|for fixed variant
/// |0000000000000000| for error packet
impl fmt::Show for PacketType {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
impl fmt::Show for PacketType {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
impl Packet {
pub fn random_packet_data(seed: &[uint]) -> PacketData {
let mut rng = if seed.is_empty() { StdRng::new().unwrap() } else { SeedableRng::from_seed(seed) };
impl Packet {
pub fn random_packet_data(seed: &[uint]) -> PacketData {
let mut rng = if seed.is_empty() { StdRng::new().unwrap() } else { SeedableRng::from_seed(seed) };
- let mut payload = Vec::from_elem(distributions::Range::new(MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE + 1).ind_sample(&mut rng), 0u8);
- rng.fill_bytes(payload.as_mut_slice_());
+ let mut payload = from_elem(distributions::Range::new(MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE + 1).ind_sample(&mut rng), 0u8);
+ rng.fill_bytes(payload.as_mut_slice());
- let mut encrypted_data = Vec::from_elem(data_size as uint - FIXED_PACKET_SIZE, 0u8);
- if try_read_io!(input.read(encrypted_data.as_mut_slice_())) != encrypted_data.len() {
+ let mut encrypted_data = from_elem(data_size as uint - FIXED_PACKET_SIZE, 0u8);
+ if try_read_io!(input.read(encrypted_data.as_mut_slice())) != encrypted_data.len() {
return Err(ReadingError::UnconsistentEncryptedSize)
}
let mut data = match crypto::decrypt(encrypted_data.as_slice(), iv_from_timestamp(timestamp).as_slice()) {
return Err(ReadingError::UnconsistentEncryptedSize)
}
let mut data = match crypto::decrypt(encrypted_data.as_slice(), iv_from_timestamp(timestamp).as_slice()) {
if try_read_io!(input.read(&mut mac_read)) != mac_read.len() {
return Err(ReadingError::UnconsistentMACSize)
}
if try_read_io!(input.read(&mut mac_read)) != mac_read.len() {
return Err(ReadingError::UnconsistentMACSize)
}
return Err(ReadingError::Data)
}
match packet_type { 0x0A => Error(ErrorType::Crypt), _ => Error(ErrorType::Auth) }
return Err(ReadingError::Data)
}
match packet_type { 0x0A => Error(ErrorType::Crypt), _ => Error(ErrorType::Auth) }