Merge pull request #282 from DaGenix/fixups

cosmycoder · cosmycoder · commit c13b947debc0 · 2015-03-30T01:36:59.000-04:00
Fix some warnings
diff --git a/src/aes.rs b/src/aes.rs
@@ -30,23 +30,23 @@ pub fn ecb_encryptor<X: PaddingProcessor + Send + 'static>(
     if util::supports_aesni() {
         let aes_enc = aesni::AesNiEncryptor::new(key_size, key);
         let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-        enc as Box<Encryptor>
+        enc
     } else {
         match key_size {
             KeySize::KeySize128 => {
                 let aes_enc = aessafe::AesSafe128Encryptor::new(key);
                 let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-                enc as Box<Encryptor>
+                enc
             }
             KeySize::KeySize192 => {
                 let aes_enc = aessafe::AesSafe192Encryptor::new(key);
                 let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-                enc as Box<Encryptor>
+                enc
             }
             KeySize::KeySize256 => {
                 let aes_enc = aessafe::AesSafe256Encryptor::new(key);
                 let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-                enc as Box<Encryptor>
+                enc
             }
         }
     }
@@ -62,17 +62,17 @@ pub fn ecb_encryptor<X: PaddingProcessor + Send + 'static>(
         KeySize::KeySize128 => {
             let aes_enc = aessafe::AesSafe128Encryptor::new(key);
             let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-            enc as Box<Encryptor>
+            enc
         }
         KeySize::KeySize192 => {
             let aes_enc = aessafe::AesSafe192Encryptor::new(key);
             let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-            enc as Box<Encryptor>
+            enc
         }
         KeySize::KeySize256 => {
             let aes_enc = aessafe::AesSafe256Encryptor::new(key);
             let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-            enc as Box<Encryptor>
+            enc
         }
     }
 }
@@ -86,23 +86,23 @@ pub fn ecb_decryptor<X: PaddingProcessor + Send + 'static>(
     if util::supports_aesni() {
         let aes_dec = aesni::AesNiDecryptor::new(key_size, key);
         let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-        dec as Box<Decryptor>
+        dec
     } else {
         match key_size {
             KeySize::KeySize128 => {
                 let aes_dec = aessafe::AesSafe128Decryptor::new(key);
                 let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-                dec as Box<Decryptor>
+                dec
             }
             KeySize::KeySize192 => {
                 let aes_dec = aessafe::AesSafe192Decryptor::new(key);
                 let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-                dec as Box<Decryptor>
+                dec
             }
             KeySize::KeySize256 => {
                 let aes_dec = aessafe::AesSafe256Decryptor::new(key);
                 let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-                dec as Box<Decryptor>
+                dec
             }
         }
     }
@@ -118,17 +118,17 @@ pub fn ecb_decryptor<X: PaddingProcessor + Send + 'static>(
         KeySize::KeySize128 => {
             let aes_dec = aessafe::AesSafe128Decryptor::new(key);
             let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-            dec as Box<Decryptor>
+            dec
         }
         KeySize::KeySize192 => {
             let aes_dec = aessafe::AesSafe192Decryptor::new(key);
             let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-            dec as Box<Decryptor>
+            dec
         }
         KeySize::KeySize256 => {
             let aes_dec = aessafe::AesSafe256Decryptor::new(key);
             let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-            dec as Box<Decryptor>
+            dec
         }
     }
 }
@@ -143,23 +143,23 @@ pub fn cbc_encryptor<X: PaddingProcessor + Send + 'static>(
     if util::supports_aesni() {
         let aes_enc = aesni::AesNiEncryptor::new(key_size, key);
         let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-        enc as Box<Encryptor>
+        enc
     } else {
         match key_size {
             KeySize::KeySize128 => {
                 let aes_enc = aessafe::AesSafe128Encryptor::new(key);
                 let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-                enc as Box<Encryptor>
+                enc
             }
             KeySize::KeySize192 => {
                 let aes_enc = aessafe::AesSafe192Encryptor::new(key);
                 let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-                enc as Box<Encryptor>
+                enc
             }
             KeySize::KeySize256 => {
                 let aes_enc = aessafe::AesSafe256Encryptor::new(key);
                 let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-                enc as Box<Encryptor>
+                enc
             }
         }
     }
@@ -176,17 +176,17 @@ pub fn cbc_encryptor<X: PaddingProcessor + Send + 'static>(
         KeySize::KeySize128 => {
             let aes_enc = aessafe::AesSafe128Encryptor::new(key);
             let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-            enc as Box<Encryptor>
+            enc
         }
         KeySize::KeySize192 => {
             let aes_enc = aessafe::AesSafe192Encryptor::new(key);
             let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-            enc as Box<Encryptor>
+            enc
         }
         KeySize::KeySize256 => {
             let aes_enc = aessafe::AesSafe256Encryptor::new(key);
             let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-            enc as Box<Encryptor>
+            enc
         }
     }
 }
@@ -201,23 +201,23 @@ pub fn cbc_decryptor<X: PaddingProcessor + Send + 'static>(
     if util::supports_aesni() {
         let aes_dec = aesni::AesNiDecryptor::new(key_size, key);
         let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-        dec as Box<Decryptor>
+        dec
     } else {
         match key_size {
             KeySize::KeySize128 => {
                 let aes_dec = aessafe::AesSafe128Decryptor::new(key);
                 let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-                dec as Box<Decryptor>
+                dec
             }
             KeySize::KeySize192 => {
                 let aes_dec = aessafe::AesSafe192Decryptor::new(key);
                 let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-                dec as Box<Decryptor>
+                dec
             }
             KeySize::KeySize256 => {
                 let aes_dec = aessafe::AesSafe256Decryptor::new(key);
                 let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-                dec as Box<Decryptor>
+                dec
             }
         }
     }
@@ -258,23 +258,23 @@ pub fn ctr(
     if util::supports_aesni() {
         let aes_dec = aesni::AesNiEncryptor::new(key_size, key);
         let dec = Box::new(CtrMode::new(aes_dec, iv.to_vec()));
-        dec as Box<SynchronousStreamCipher>
+        dec
     } else {
         match key_size {
             KeySize::KeySize128 => {
                 let aes_dec = aessafe::AesSafe128EncryptorX8::new(key);
                 let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-                dec as Box<SynchronousStreamCipher>
+                dec
             }
             KeySize::KeySize192 => {
                 let aes_dec = aessafe::AesSafe192EncryptorX8::new(key);
                 let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-                dec as Box<SynchronousStreamCipher>
+                dec
             }
             KeySize::KeySize256 => {
                 let aes_dec = aessafe::AesSafe256EncryptorX8::new(key);
                 let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-                dec as Box<SynchronousStreamCipher>
+                dec
             }
         }
     }
diff --git a/src/cryptoutil.rs b/src/cryptoutil.rs
@@ -96,8 +96,8 @@ pub fn write_u32v_le (dst: &mut[u8], input: &[u32]) {
 pub fn read_u64v_be(dst: &mut[u64], input: &[u8]) {
     assert!(dst.len() * 8 == input.len());
     unsafe {
-        let mut x = dst.get_unchecked_mut(0) as *mut u64;
-        let mut y = input.get_unchecked(0) as *const u8;
+        let mut x: *mut u64 = dst.get_unchecked_mut(0);
+        let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u64 = mem::uninitialized();
             ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 8);
@@ -112,8 +112,8 @@ pub fn read_u64v_be(dst: &mut[u64], input: &[u8]) {
 pub fn read_u64v_le(dst: &mut[u64], input: &[u8]) {
     assert!(dst.len() * 8 == input.len());
     unsafe {
-        let mut x = dst.get_unchecked_mut(0) as *mut u64;
-        let mut y = input.get_unchecked(0) as *const u8;
+        let mut x: *mut u64 = dst.get_unchecked_mut(0);
+        let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u64 = mem::uninitialized();
             ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 8);
@@ -128,8 +128,8 @@ pub fn read_u64v_le(dst: &mut[u64], input: &[u8]) {
 pub fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
     assert!(dst.len() * 4 == input.len());
     unsafe {
-        let mut x = dst.get_unchecked_mut(0) as *mut u32;
-        let mut y = input.get_unchecked(0) as *const u8;
+        let mut x: *mut u32 = dst.get_unchecked_mut(0);
+        let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u32 = mem::uninitialized();
             ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 4);
@@ -144,8 +144,8 @@ pub fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
 pub fn read_u32v_le(dst: &mut[u32], input: &[u8]) {
     assert!(dst.len() * 4 == input.len());
     unsafe {
-        let mut x = dst.get_unchecked_mut(0) as *mut u32;
-        let mut y = input.get_unchecked(0) as *const u8;
+        let mut x: *mut u32 = dst.get_unchecked_mut(0);
+        let mut y: *const u8 = input.get_unchecked(0);
         for _ in (0..dst.len()) {
             let mut tmp: u32 = mem::uninitialized();
             ptr::copy_nonoverlapping(&mut tmp as *mut _ as *mut u8, y, 4);
diff --git a/src/hc128.rs b/src/hc128.rs
@@ -52,7 +52,7 @@ impl Hc128 {
         }
 
         for i in 16..1280 {
-            w[i] = (f2(w[i - 2]).wrapping_add(w[i - 7]).wrapping_add(f1(w[i - 15])).wrapping_add(w[i - 16]).wrapping_add(i as u32)) as u32;
+            w[i] = f2(w[i - 2]).wrapping_add(w[i - 7]).wrapping_add(f1(w[i - 15])).wrapping_add(w[i - 16]).wrapping_add(i as u32);
         }
 
         // Copy contents of w into p and q
@@ -126,7 +126,7 @@ impl SynchronousStreamCipher for Hc128 {
                 *outb = *inb ^ self.next();
             }
         } else {
-            let mut data_index = 0 as usize;
+            let mut data_index = 0;
             let data_index_end = data_index + input.len();
 
             /*  Process any unused keystream (self.buffer) 
diff --git a/src/poly1305.rs b/src/poly1305.rs
@@ -83,7 +83,7 @@ impl Poly1305 {
         d2 += c as u64; c = (d2 >> 26) as u32; h2 = d2 as u32 & 0x3ffffff;
         d3 += c as u64; c = (d3 >> 26) as u32; h3 = d3 as u32 & 0x3ffffff;
         d4 += c as u64; c = (d4 >> 26) as u32; h4 = d4 as u32 & 0x3ffffff;
-        h0 += c * 5;    c = (h0 >> 26) as u32; h0 = h0 & 0x3ffffff;
+        h0 += c * 5;    c = h0 >> 26; h0 = h0 & 0x3ffffff;
         h1 += c;
 
         self.h[0] = h0;
diff --git a/src/scrypt.rs b/src/scrypt.rs
@@ -347,7 +347,7 @@ pub fn scrypt_check(password: &str, hashed_value: &str) -> Result<bool, &'static
             match fstr {
                 "0" => {
                     if pvec.len() != 3 { return Err(ERR_STR); }
-                    let log_n = pvec[0] as u8;
+                    let log_n = pvec[0];
                     let r = pvec[1] as u32;
                     let p = pvec[2] as u32;
                     params = ScryptParams::new(log_n, r, p);
diff --git a/src/sosemanuk.rs b/src/sosemanuk.rs

Original file line number	Diff line number	Diff line change
`@@ -30,23 +30,23 @@ pub fn ecb_encryptor<X: PaddingProcessor + Send + 'static>(`
`30`	`30`	`if util::supports_aesni() {`
`31`	`31`	`let aes_enc = aesni::AesNiEncryptor::new(key_size, key);`
`32`	`32`	`let enc = Box::new(EcbEncryptor::new(aes_enc, padding));`
`33`		`- enc as Box<Encryptor>`
	`33`	`+ enc`
`34`	`34`	`} else {`
`35`	`35`	`match key_size {`
`36`	`36`	`KeySize::KeySize128 => {`
`37`	`37`	`let aes_enc = aessafe::AesSafe128Encryptor::new(key);`
`38`	`38`	`let enc = Box::new(EcbEncryptor::new(aes_enc, padding));`
`39`		`- enc as Box<Encryptor>`
	`39`	`+ enc`
`40`	`40`	`}`
`41`	`41`	`KeySize::KeySize192 => {`
`42`	`42`	`let aes_enc = aessafe::AesSafe192Encryptor::new(key);`
`43`	`43`	`let enc = Box::new(EcbEncryptor::new(aes_enc, padding));`
`44`		`- enc as Box<Encryptor>`
	`44`	`+ enc`
`45`	`45`	`}`
`46`	`46`	`KeySize::KeySize256 => {`
`47`	`47`	`let aes_enc = aessafe::AesSafe256Encryptor::new(key);`
`48`	`48`	`let enc = Box::new(EcbEncryptor::new(aes_enc, padding));`
`49`		`- enc as Box<Encryptor>`
	`49`	`+ enc`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`}`
`@@ -62,17 +62,17 @@ pub fn ecb_encryptor<X: PaddingProcessor + Send + 'static>(`
`62`	`62`	`KeySize::KeySize128 => {`
`63`	`63`	`let aes_enc = aessafe::AesSafe128Encryptor::new(key);`
`64`	`64`	`let enc = Box::new(EcbEncryptor::new(aes_enc, padding));`
`65`		`- enc as Box<Encryptor>`
	`65`	`+ enc`
`66`	`66`	`}`
`67`	`67`	`KeySize::KeySize192 => {`
`68`	`68`	`let aes_enc = aessafe::AesSafe192Encryptor::new(key);`
`69`	`69`	`let enc = Box::new(EcbEncryptor::new(aes_enc, padding));`
`70`		`- enc as Box<Encryptor>`
	`70`	`+ enc`
`71`	`71`	`}`
`72`	`72`	`KeySize::KeySize256 => {`
`73`	`73`	`let aes_enc = aessafe::AesSafe256Encryptor::new(key);`
`74`	`74`	`let enc = Box::new(EcbEncryptor::new(aes_enc, padding));`
`75`		`- enc as Box<Encryptor>`
	`75`	`+ enc`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`	`}`
`@@ -86,23 +86,23 @@ pub fn ecb_decryptor<X: PaddingProcessor + Send + 'static>(`
`86`	`86`	`if util::supports_aesni() {`
`87`	`87`	`let aes_dec = aesni::AesNiDecryptor::new(key_size, key);`
`88`	`88`	`let dec = Box::new(EcbDecryptor::new(aes_dec, padding));`
`89`		`- dec as Box<Decryptor>`
	`89`	`+ dec`
`90`	`90`	`} else {`
`91`	`91`	`match key_size {`
`92`	`92`	`KeySize::KeySize128 => {`
`93`	`93`	`let aes_dec = aessafe::AesSafe128Decryptor::new(key);`
`94`	`94`	`let dec = Box::new(EcbDecryptor::new(aes_dec, padding));`
`95`		`- dec as Box<Decryptor>`
	`95`	`+ dec`
`96`	`96`	`}`
`97`	`97`	`KeySize::KeySize192 => {`
`98`	`98`	`let aes_dec = aessafe::AesSafe192Decryptor::new(key);`
`99`	`99`	`let dec = Box::new(EcbDecryptor::new(aes_dec, padding));`
`100`		`- dec as Box<Decryptor>`
	`100`	`+ dec`
`101`	`101`	`}`
`102`	`102`	`KeySize::KeySize256 => {`
`103`	`103`	`let aes_dec = aessafe::AesSafe256Decryptor::new(key);`
`104`	`104`	`let dec = Box::new(EcbDecryptor::new(aes_dec, padding));`
`105`		`- dec as Box<Decryptor>`
	`105`	`+ dec`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`}`
`@@ -118,17 +118,17 @@ pub fn ecb_decryptor<X: PaddingProcessor + Send + 'static>(`
`118`	`118`	`KeySize::KeySize128 => {`
`119`	`119`	`let aes_dec = aessafe::AesSafe128Decryptor::new(key);`
`120`	`120`	`let dec = Box::new(EcbDecryptor::new(aes_dec, padding));`
`121`		`- dec as Box<Decryptor>`
	`121`	`+ dec`
`122`	`122`	`}`
`123`	`123`	`KeySize::KeySize192 => {`
`124`	`124`	`let aes_dec = aessafe::AesSafe192Decryptor::new(key);`
`125`	`125`	`let dec = Box::new(EcbDecryptor::new(aes_dec, padding));`
`126`		`- dec as Box<Decryptor>`
	`126`	`+ dec`
`127`	`127`	`}`
`128`	`128`	`KeySize::KeySize256 => {`
`129`	`129`	`let aes_dec = aessafe::AesSafe256Decryptor::new(key);`
`130`	`130`	`let dec = Box::new(EcbDecryptor::new(aes_dec, padding));`
`131`		`- dec as Box<Decryptor>`
	`131`	`+ dec`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`	`}`
`@@ -143,23 +143,23 @@ pub fn cbc_encryptor<X: PaddingProcessor + Send + 'static>(`
`143`	`143`	`if util::supports_aesni() {`
`144`	`144`	`let aes_enc = aesni::AesNiEncryptor::new(key_size, key);`
`145`	`145`	`let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));`
`146`		`- enc as Box<Encryptor>`
	`146`	`+ enc`
`147`	`147`	`} else {`
`148`	`148`	`match key_size {`
`149`	`149`	`KeySize::KeySize128 => {`
`150`	`150`	`let aes_enc = aessafe::AesSafe128Encryptor::new(key);`
`151`	`151`	`let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));`
`152`		`- enc as Box<Encryptor>`
	`152`	`+ enc`
`153`	`153`	`}`
`154`	`154`	`KeySize::KeySize192 => {`
`155`	`155`	`let aes_enc = aessafe::AesSafe192Encryptor::new(key);`
`156`	`156`	`let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));`
`157`		`- enc as Box<Encryptor>`
	`157`	`+ enc`
`158`	`158`	`}`
`159`	`159`	`KeySize::KeySize256 => {`
`160`	`160`	`let aes_enc = aessafe::AesSafe256Encryptor::new(key);`
`161`	`161`	`let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));`
`162`		`- enc as Box<Encryptor>`
	`162`	`+ enc`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`	`}`
`@@ -176,17 +176,17 @@ pub fn cbc_encryptor<X: PaddingProcessor + Send + 'static>(`
`176`	`176`	`KeySize::KeySize128 => {`
`177`	`177`	`let aes_enc = aessafe::AesSafe128Encryptor::new(key);`
`178`	`178`	`let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));`
`179`		`- enc as Box<Encryptor>`
	`179`	`+ enc`
`180`	`180`	`}`
`181`	`181`	`KeySize::KeySize192 => {`
`182`	`182`	`let aes_enc = aessafe::AesSafe192Encryptor::new(key);`
`183`	`183`	`let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));`
`184`		`- enc as Box<Encryptor>`
	`184`	`+ enc`
`185`	`185`	`}`
`186`	`186`	`KeySize::KeySize256 => {`
`187`	`187`	`let aes_enc = aessafe::AesSafe256Encryptor::new(key);`
`188`	`188`	`let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));`
`189`		`- enc as Box<Encryptor>`
	`189`	`+ enc`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`	`}`
`@@ -201,23 +201,23 @@ pub fn cbc_decryptor<X: PaddingProcessor + Send + 'static>(`
`201`	`201`	`if util::supports_aesni() {`
`202`	`202`	`let aes_dec = aesni::AesNiDecryptor::new(key_size, key);`
`203`	`203`	`let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));`
`204`		`- dec as Box<Decryptor>`
	`204`	`+ dec`
`205`	`205`	`} else {`
`206`	`206`	`match key_size {`
`207`	`207`	`KeySize::KeySize128 => {`
`208`	`208`	`let aes_dec = aessafe::AesSafe128Decryptor::new(key);`
`209`	`209`	`let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));`
`210`		`- dec as Box<Decryptor>`
	`210`	`+ dec`
`211`	`211`	`}`
`212`	`212`	`KeySize::KeySize192 => {`
`213`	`213`	`let aes_dec = aessafe::AesSafe192Decryptor::new(key);`
`214`	`214`	`let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));`
`215`		`- dec as Box<Decryptor>`
	`215`	`+ dec`
`216`	`216`	`}`
`217`	`217`	`KeySize::KeySize256 => {`
`218`	`218`	`let aes_dec = aessafe::AesSafe256Decryptor::new(key);`
`219`	`219`	`let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));`
`220`		`- dec as Box<Decryptor>`
	`220`	`+ dec`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`	`}`
`@@ -258,23 +258,23 @@ pub fn ctr(`
`258`	`258`	`if util::supports_aesni() {`
`259`	`259`	`let aes_dec = aesni::AesNiEncryptor::new(key_size, key);`
`260`	`260`	`let dec = Box::new(CtrMode::new(aes_dec, iv.to_vec()));`
`261`		`- dec as Box<SynchronousStreamCipher>`
	`261`	`+ dec`
`262`	`262`	`} else {`
`263`	`263`	`match key_size {`
`264`	`264`	`KeySize::KeySize128 => {`
`265`	`265`	`let aes_dec = aessafe::AesSafe128EncryptorX8::new(key);`
`266`	`266`	`let dec = Box::new(CtrModeX8::new(aes_dec, iv));`
`267`		`- dec as Box<SynchronousStreamCipher>`
	`267`	`+ dec`
`268`	`268`	`}`
`269`	`269`	`KeySize::KeySize192 => {`
`270`	`270`	`let aes_dec = aessafe::AesSafe192EncryptorX8::new(key);`
`271`	`271`	`let dec = Box::new(CtrModeX8::new(aes_dec, iv));`
`272`		`- dec as Box<SynchronousStreamCipher>`
	`272`	`+ dec`
`273`	`273`	`}`
`274`	`274`	`KeySize::KeySize256 => {`
`275`	`275`	`let aes_dec = aessafe::AesSafe256EncryptorX8::new(key);`
`276`	`276`	`let dec = Box::new(CtrModeX8::new(aes_dec, iv));`
`277`		`- dec as Box<SynchronousStreamCipher>`
	`277`	`+ dec`
`278`	`278`	`}`
`279`	`279`	`}`
`280`	`280`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ impl Hc128 {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`for i in 16..1280 {`
`55`		`- w[i] = (f2(w[i - 2]).wrapping_add(w[i - 7]).wrapping_add(f1(w[i - 15])).wrapping_add(w[i - 16]).wrapping_add(i as u32)) as u32;`
	`55`	`+ w[i] = f2(w[i - 2]).wrapping_add(w[i - 7]).wrapping_add(f1(w[i - 15])).wrapping_add(w[i - 16]).wrapping_add(i as u32);`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`// Copy contents of w into p and q`
`@@ -126,7 +126,7 @@ impl SynchronousStreamCipher for Hc128 {`
`126`	`126`	`outb = inb ^ self.next();`
`127`	`127`	`}`
`128`	`128`	`} else {`
`129`		`- let mut data_index = 0 as usize;`
	`129`	`+ let mut data_index = 0;`
`130`	`130`	`let data_index_end = data_index + input.len();`
`131`	`131`
`132`	`132`	`/* Process any unused keystream (self.buffer)`