vendor/block-buffer/src/paddings.rs

   1 use byte_tools::{zero, set};
   2
   3 /// Trait for padding messages divided into blocks
   4 pub trait Padding {
   5     /// Pads `block` filled with data up to `pos`
   6     fn pad(block: &mut [u8], pos: usize);
   7 }
   8
   9 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
  10 /// Error for indicating failed unpadding process
  11 pub struct UnpadError;
  12
  13 /// Trait for extracting oringinal message from padded medium
  14 pub trait Unpadding {
  15     /// Unpad given `data` by truncating it according to the used padding.
  16     /// In case of the malformed padding will return `UnpadError`
  17     fn unpad(data: &[u8]) -> Result<&[u8], UnpadError>;
  18 }
  19
  20
  21 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
  22 pub enum ZeroPadding{}
  23
  24 impl Padding for ZeroPadding {
  25     #[inline]
  26     fn pad(block: &mut [u8], pos: usize) {
  27         zero(&mut block[pos..])
  28     }
  29 }
  30
  31 impl Unpadding for ZeroPadding {
  32     #[inline]
  33     fn unpad(data: &[u8]) -> Result<&[u8], UnpadError> {
  34         let mut n = data.len() - 1;
  35         while n != 0 {
  36             if data[n] != 0 {
  37                 break;
  38             }
  39             n -= 1;
  40         }
  41         Ok(&data[..n+1])
  42     }
  43 }
  44
  45 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
  46 pub enum Pkcs7{}
  47
  48 impl Padding for Pkcs7 {
  49     #[inline]
  50     fn pad(block: &mut [u8], pos: usize) {
  51         let n = block.len() - pos;
  52         set(&mut block[pos..], n as u8);
  53     }
  54 }
  55
  56 impl Unpadding for Pkcs7 {
  57     #[inline]
  58     fn unpad(data: &[u8]) -> Result<&[u8], UnpadError> {
  59         if data.is_empty() { return Err(UnpadError); }
  60         let l = data.len();
  61         let n = data[l-1];
  62         if n == 0 {
  63             return Err(UnpadError)
  64         }
  65         for v in &data[l-n as usize..l-1] {
  66             if *v != n { return Err(UnpadError); }
  67         }
  68         Ok(&data[..l-n as usize])
  69     }
  70 }
  71
  72 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
  73 pub enum AnsiX923{}
  74
  75 impl Padding for AnsiX923 {
  76     #[inline]
  77     fn pad(block: &mut [u8], pos: usize) {
  78         let n = block.len() - 1;
  79         zero(&mut block[pos..n]);
  80         block[n] = (n - pos) as u8;
  81     }
  82 }
  83
  84 impl Unpadding for AnsiX923 {
  85     #[inline]
  86     fn unpad(data: &[u8]) -> Result<&[u8], UnpadError> {
  87         if data.is_empty() { return Err(UnpadError); }
  88         let l = data.len();
  89         let n = data[l-1] as usize;
  90         if n == 0 {
  91             return Err(UnpadError)
  92         }
  93         for v in &data[l-n..l-1] {
  94             if *v != 0 { return Err(UnpadError); }
  95         }
  96         Ok(&data[..l-n])
  97     }
  98 }
  99
 100
 101
 102 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 103 pub enum Iso7816{}
 104
 105 impl Padding for Iso7816 {
 106     #[inline]
 107     fn pad(block: &mut [u8], pos: usize) {
 108         let n = block.len() - pos;
 109         block[pos] = 0x80;
 110         for b in block[pos+1..].iter_mut() {
 111             *b = n as u8;
 112         }
 113     }
 114 }
 115
 116 impl Unpadding for Iso7816 {
 117     fn unpad(data: &[u8]) -> Result<&[u8], UnpadError> {
 118         if data.is_empty() { return Err(UnpadError); }
 119         let mut n = data.len() - 1;
 120         while n != 0 {
 121             if data[n] != 0 {
 122                 break;
 123             }
 124             n -= 1;
 125         }
 126         if data[n] != 0x80 { return Err(UnpadError); }
 127         Ok(&data[..n])
 128     }
 129 }