ChaCha: set nonce and rounds at construction time; fix 64-bit counter

Author: dhardy

rand_core/src/impls.rs

@@ -219,20 +219,38 @@ impl<R: BlockRngCore> BlockRng<R> {
     }
 
     /// Return a reference the wrapped `BlockRngCore`.
+    #[inline(always)]
     pub fn inner(&self) -> &R {
         &self.core
     }
 
     /// Return a mutable reference the wrapped `BlockRngCore`.
+    #[inline(always)]
     pub fn inner_mut(&mut self) -> &mut R {
         &mut self.core
     }
-
-    // Reset the number of available results.
-    // This will force a new set of results to be generated on next use.
+    
+    /// Get the index into the result buffer
+    #[inline(always)]
+    pub fn index(&self) -> usize {
+        self.index
+    }
+    
+    /// Reset the number of available results.
+    /// This will force a new set of results to be generated on next use.
+    #[inline(always)]
     pub fn reset(&mut self) {
         self.index = self.results.as_ref().len();
     }
+    
+    /// Generate a new set of results immediately, setting the index to the
+    /// given value.
+    #[inline(always)]
+    pub fn generate(&mut self, index: usize) {
+        assert!(index < self.results.as_ref().len());
+        self.core.generate(&mut self.results);
+        self.index = index;
+    }
 }
 
 impl<R: BlockRngCore<Item=u32>> RngCore for BlockRng<R>
@@ -241,8 +259,7 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         if self.index >= self.results.as_ref().len() {
-            self.core.generate(&mut self.results);
-            self.index = 0;
+            self.generate(0);
         }
 
         let value = self.results.as_ref()[self.index];
@@ -271,13 +288,11 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
             // Read an u64 from the current index
             read_u64(self.results.as_ref(), index)
         } else if index >= len {
-            self.core.generate(&mut self.results);
-            self.index = 2;
+            self.generate(2);
             read_u64(self.results.as_ref(), 0)
         } else {
             let x = u64::from(self.results.as_ref()[len-1]);
-            self.core.generate(&mut self.results);
-            self.index = 1;
+            self.generate(1);
             let y = u64::from(self.results.as_ref()[0]);
             (y << 32) | x
         }
@@ -329,8 +344,7 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
         let mut read_len = 0;
         while read_len < dest.len() {
             if self.index >= self.results.as_ref().len() {
-                self.core.generate(&mut self.results);
-                self.index = 0;
+                self.generate(0);
             }
             let (consumed_u32, filled_u8) =
                 fill_via_u32_chunks(&self.results.as_ref()[self.index..],