1 // Copyright 2016 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "encode_values.h"
6
7 #include <string_view>
8
9 #include <gtest/gtest.h>
10 #include "parse_values.h"
11
12 namespace bssl::der::test {
13
14 namespace {
15
16 template <size_t N>
ToStringView(const uint8_t (& data)[N])17 std::string_view ToStringView(const uint8_t (&data)[N]) {
18 return std::string_view(reinterpret_cast<const char *>(data), N);
19 }
20
21 } // namespace
22
TEST(EncodeValuesTest,EncodePosixTimeAsGeneralizedTime)23 TEST(EncodeValuesTest, EncodePosixTimeAsGeneralizedTime) {
24 // Fri, 24 Jun 2016 17:04:54 GMT
25 int64_t time = 1466787894;
26 GeneralizedTime generalized_time;
27 ASSERT_TRUE(EncodePosixTimeAsGeneralizedTime(time, &generalized_time));
28 EXPECT_EQ(2016, generalized_time.year);
29 EXPECT_EQ(6, generalized_time.month);
30 EXPECT_EQ(24, generalized_time.day);
31 EXPECT_EQ(17, generalized_time.hours);
32 EXPECT_EQ(4, generalized_time.minutes);
33 EXPECT_EQ(54, generalized_time.seconds);
34 }
35
TEST(EncodeValuesTest,GeneralizedTimeToPosixTime)36 TEST(EncodeValuesTest, GeneralizedTimeToPosixTime) {
37 GeneralizedTime generalized_time;
38 generalized_time.year = 2016;
39 generalized_time.month = 6;
40 generalized_time.day = 24;
41 generalized_time.hours = 17;
42 generalized_time.minutes = 4;
43 generalized_time.seconds = 54;
44 int64_t time;
45 ASSERT_TRUE(GeneralizedTimeToPosixTime(generalized_time, &time));
46 EXPECT_EQ(1466787894, time);
47 }
48
49 // As Posix times use BoringSSL's POSIX time routines underneath the covers
50 // these should not have any issues on 32 bit platforms.
TEST(EncodeValuesTest,GeneralizedTimeToPosixTimeAfter32BitPosixMaxYear)51 TEST(EncodeValuesTest, GeneralizedTimeToPosixTimeAfter32BitPosixMaxYear) {
52 GeneralizedTime generalized_time;
53 generalized_time.year = 2039;
54 generalized_time.month = 1;
55 generalized_time.day = 1;
56 generalized_time.hours = 0;
57 generalized_time.minutes = 0;
58 generalized_time.seconds = 0;
59 int64_t time;
60 ASSERT_TRUE(GeneralizedTimeToPosixTime(generalized_time, &time));
61
62 generalized_time.day = 0; // Invalid day of month should fail.
63 EXPECT_FALSE(GeneralizedTimeToPosixTime(generalized_time, &time));
64 }
65
TEST(EncodeValuesTest,EncodeGeneralizedTime)66 TEST(EncodeValuesTest, EncodeGeneralizedTime) {
67 GeneralizedTime time;
68 time.year = 2014;
69 time.month = 12;
70 time.day = 18;
71 time.hours = 16;
72 time.minutes = 12;
73 time.seconds = 59;
74
75 // Encode a time where no components have leading zeros.
76 uint8_t out[kGeneralizedTimeLength];
77 ASSERT_TRUE(EncodeGeneralizedTime(time, out));
78 EXPECT_EQ("20141218161259Z", ToStringView(out));
79
80 // Test bounds on all components. Note the encoding function does not validate
81 // the input is a valid time, only that it is encodable.
82 time.year = 0;
83 time.month = 0;
84 time.day = 0;
85 time.hours = 0;
86 time.minutes = 0;
87 time.seconds = 0;
88 ASSERT_TRUE(EncodeGeneralizedTime(time, out));
89 EXPECT_EQ("00000000000000Z", ToStringView(out));
90
91 time.year = 9999;
92 time.month = 99;
93 time.day = 99;
94 time.hours = 99;
95 time.minutes = 99;
96 time.seconds = 99;
97 ASSERT_TRUE(EncodeGeneralizedTime(time, out));
98 EXPECT_EQ("99999999999999Z", ToStringView(out));
99
100 time.year = 10000;
101 EXPECT_FALSE(EncodeGeneralizedTime(time, out));
102
103 time.year = 2000;
104 time.month = 100;
105 EXPECT_FALSE(EncodeGeneralizedTime(time, out));
106 }
107
TEST(EncodeValuesTest,EncodeUTCTime)108 TEST(EncodeValuesTest, EncodeUTCTime) {
109 GeneralizedTime time;
110 time.year = 2014;
111 time.month = 12;
112 time.day = 18;
113 time.hours = 16;
114 time.minutes = 12;
115 time.seconds = 59;
116
117 // Encode a time where no components have leading zeros.
118 uint8_t out[kUTCTimeLength];
119 ASSERT_TRUE(EncodeUTCTime(time, out));
120 EXPECT_EQ("141218161259Z", ToStringView(out));
121
122 time.year = 2049;
123 ASSERT_TRUE(EncodeUTCTime(time, out));
124 EXPECT_EQ("491218161259Z", ToStringView(out));
125
126 time.year = 2000;
127 ASSERT_TRUE(EncodeUTCTime(time, out));
128 EXPECT_EQ("001218161259Z", ToStringView(out));
129
130 time.year = 1999;
131 ASSERT_TRUE(EncodeUTCTime(time, out));
132 EXPECT_EQ("991218161259Z", ToStringView(out));
133
134 time.year = 1950;
135 ASSERT_TRUE(EncodeUTCTime(time, out));
136 EXPECT_EQ("501218161259Z", ToStringView(out));
137
138 time.year = 2050;
139 EXPECT_FALSE(EncodeUTCTime(time, out));
140
141 time.year = 1949;
142 EXPECT_FALSE(EncodeUTCTime(time, out));
143
144 // Test bounds on all components. Note the encoding function does not validate
145 // the input is a valid time, only that it is encodable.
146 time.year = 2000;
147 time.month = 0;
148 time.day = 0;
149 time.hours = 0;
150 time.minutes = 0;
151 time.seconds = 0;
152 ASSERT_TRUE(EncodeUTCTime(time, out));
153 EXPECT_EQ("000000000000Z", ToStringView(out));
154
155 time.year = 1999;
156 time.month = 99;
157 time.day = 99;
158 time.hours = 99;
159 time.minutes = 99;
160 time.seconds = 99;
161 ASSERT_TRUE(EncodeUTCTime(time, out));
162 EXPECT_EQ("999999999999Z", ToStringView(out));
163
164 time.year = 2000;
165 time.month = 100;
166 EXPECT_FALSE(EncodeUTCTime(time, out));
167 }
168
169 } // namespace bssl::der::test
170