4146905603

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/google/OpenSK/commit/<a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/c08a2423411f10b525530d2ce3dbb1e6128b750e">c08a24234">&lt;a href=&quot;https://github.com/google/OpenSK/commit/</a><a class="double-link" href="https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/c08a2423411f10b525530d2ce3dbb1e6128b750e">c08a24234</a><a href="https://github.com/google/OpenSK/commit/c08a2423411f10b525530d2ce3dbb1e6128b750e">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/c08a2423411f10b525530d2ce3dbb1e6128b750e&quot;&gt;c08a24234&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/c08a2423411f10b525530d2ce3dbb1e6128b750e&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot... (continued)

Pull Request Pull Request #580: Overview: Add tock v2 support

Run Details

246 of 246 new or added lines in 17 files covered. (100.0%)

15200 of 17297 relevant lines covered (87.88%)

520749.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

37.04

/libraries/rng256/src/lib.rs

// Copyright 2019-2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#![cfg_attr(not(feature = "std"), no_std)]

use core::marker::PhantomData;

use arrayref::array_ref;
use libtock_drivers::rng::{self, Config};
use libtock_platform::{DefaultConfig, Syscalls};
#[cfg(feature = "std")]
use rand::Rng;

// Lightweight RNG trait to generate uniformly distributed 256 bits.
pub trait Rng256 {
    fn gen_uniform_u8x32(&mut self) -> [u8; 32];

    fn gen_uniform_u32x8(&mut self) -> [u32; 8] {
        bytes_to_u32(self.gen_uniform_u8x32())
    }
}

// The TockOS rng driver fills a buffer of bytes, but we need 32-bit words for ECDSA.
// This function does the conversion in safe Rust, using the native endianness to avoid unnecessary
// instructions.
// An unsafe one-line equivalent could be implemented with mem::transmute, but let's use safe Rust
// when possible.
fn bytes_to_u32(bytes: [u8; 32]) -> [u32; 8] {
    let mut result: [u32; 8] = [Default::default(); 8];
    for (i, r) in result.iter_mut().enumerate() {
        *r = u32::from_ne_bytes(*array_ref![bytes, 4 * i, 4]);
    }
    result
}

/// RNG backed by the TockOS rng driver.
pub struct TockRng256<S: Syscalls, C: Config = DefaultConfig> {
    _syscalls: PhantomData<S>,
    _config: PhantomData<C>,
}

impl<S: Syscalls, C: Config> TockRng256<S, C> {
    pub fn new() -> Self {
        Self {
            _syscalls: PhantomData,
            _config: PhantomData,
        }
    }
}

impl<S: Syscalls, C: Config> Rng256 for TockRng256<S, C> {
    fn gen_uniform_u8x32(&mut self) -> [u8; 32] {
        let mut buf: [u8; 32] = [Default::default(); 32];
        rng::Rng::<S, C>::fill_buffer(&mut buf);
        buf
    }
}

/// For tests on the desktop, we use the cryptographically secure thread rng as entropy source.
#[cfg(feature = "std")]
pub struct ThreadRng256 {}

#[cfg(feature = "std")]
impl Rng256 for ThreadRng256 {
    fn gen_uniform_u8x32(&mut self) -> [u8; 32] {
        let mut rng = rand::thread_rng();
        let mut result = [Default::default(); 32];
        rng.fill(&mut result);
        result
    }
}

#[cfg(test)]
pub mod test {
    use super::*;

    #[test]
    fn test_bytes_to_u32() {
        // This tests that all bytes of the input are indeed used in the output, once each.
        // Otherwise the result of gen_uniform_u32x8 wouldn't be uniformly distributed.
        let bytes = b"\x00\x01\x02\x03\x04\x05\x06\x07\
                      \x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\
                      \x10\x11\x12\x13\x14\x15\x16\x17\
                      \x18\x19\x1a\x1b\x1c\x1d\x1e\x1f";
        #[cfg(target_endian = "big")]
        let expected = [
            0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617, 0x18191a1b,
            0x1c1d1e1f,
        ];
        #[cfg(target_endian = "little")]
        let expected = [
            0x03020100, 0x07060504, 0x0b0a0908, 0x0f0e0d0c, 0x13121110, 0x17161514, 0x1b1a1918,
            0x1f1e1d1c,
        ];

        assert_eq!(bytes_to_u32(*bytes), expected);
    }
}

1	// Copyright 2019-2022 Google LLC
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	#![cfg_attr(not(feature = "std"), no_std)]
16
17	use core::marker::PhantomData;
18
19	use arrayref::array_ref;
20	use libtock_drivers::rng::{self, Config};
21	use libtock_platform::{DefaultConfig, Syscalls};
22	#[cfg(feature = "std")]
23	use rand::Rng;
24
25	// Lightweight RNG trait to generate uniformly distributed 256 bits.
26	pub trait Rng256 {
27	fn gen_uniform_u8x32(&mut self) -> [u8; 32];
28
29	fn gen_uniform_u32x8(&mut self) -> [u32; 8] {	1,015✔
30	bytes_to_u32(self.gen_uniform_u8x32())	1,015✔
31	}	1,015✔
32	}
33
34	// The TockOS rng driver fills a buffer of bytes, but we need 32-bit words for ECDSA.
35	// This function does the conversion in safe Rust, using the native endianness to avoid unnecessary
36	// instructions.
37	// An unsafe one-line equivalent could be implemented with mem::transmute, but let's use safe Rust
38	// when possible.
39	fn bytes_to_u32(bytes: [u8; 32]) -> [u32; 8] {	8,120✔
40	let mut result: [u32; 8] = [Default::default(); 8];	8,120✔
41	for (i, r) in result.iter_mut().enumerate() {	64,960✔
42	r = u32::from_ne_bytes(array_ref![bytes, 4 * i, 4]);	64,960✔
43	}	64,960✔
44	result	8,120✔
45	}	8,120✔
46
47	/// RNG backed by the TockOS rng driver.
48	pub struct TockRng256<S: Syscalls, C: Config = DefaultConfig> {
49	_syscalls: PhantomData<S>,
50	_config: PhantomData<C>,
51	}
52
53	impl<S: Syscalls, C: Config> TockRng256<S, C> {
54	pub fn new() -> Self {	×
55	Self {	×
56	_syscalls: PhantomData,	×
57	_config: PhantomData,	×
58	}	×
59	}	×
60	}
61
62	impl<S: Syscalls, C: Config> Rng256 for TockRng256<S, C> {
63	fn gen_uniform_u8x32(&mut self) -> [u8; 32] {	×
64	let mut buf: [u8; 32] = [Default::default(); 32];	×
65	rng::Rng::<S, C>::fill_buffer(&mut buf);	×
66	buf	×
67	}	×
68	}
69
70	/// For tests on the desktop, we use the cryptographically secure thread rng as entropy source.
71	#[cfg(feature = "std")]
72	pub struct ThreadRng256 {}
73
74	#[cfg(feature = "std")]
75	impl Rng256 for ThreadRng256 {
76	fn gen_uniform_u8x32(&mut self) -> [u8; 32] {	×
77	let mut rng = rand::thread_rng();	×
78	let mut result = [Default::default(); 32];	×
79	rng.fill(&mut result);	×
80	result	×
81	}	×
82	}
83
84	#[cfg(test)]
85	pub mod test {
86	use super::*;
87
88	#[test]
89	fn test_bytes_to_u32() {
90	// This tests that all bytes of the input are indeed used in the output, once each.
91	// Otherwise the result of gen_uniform_u32x8 wouldn't be uniformly distributed.
92	let bytes = b"\x00\x01\x02\x03\x04\x05\x06\x07\
93	\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\
94	\x10\x11\x12\x13\x14\x15\x16\x17\
95	\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f";
96	#[cfg(target_endian = "big")]
97	let expected = [
98	0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617, 0x18191a1b,
99	0x1c1d1e1f,
100	];
101	#[cfg(target_endian = "little")]
102	let expected = [
103	0x03020100, 0x07060504, 0x0b0a0908, 0x0f0e0d0c, 0x13121110, 0x17161514, 0x1b1a1918,
104	0x1f1e1d1c,
105	];
106
107	assert_eq!(bytes_to_u32(*bytes), expected);
108	}
109	}

google / OpenSK / 4146905603

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous