| // Copyright 2016 The Chromium Authors | |
| // | |
| // 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 | |
| // | |
| // https://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. | |
| #include "encode_values.h" | |
| #include <openssl/bytestring.h> | |
| #include <openssl/nid.h> | |
| #include <openssl/posix_time.h> | |
| #include "parse_values.h" | |
| BSSL_NAMESPACE_BEGIN | |
| namespace der { | |
| namespace { | |
| bool WriteFourDigit(uint16_t value, uint8_t out[4]) { | |
| if (value >= 10000) { | |
| return false; | |
| } | |
| out[3] = '0' + (value % 10); | |
| value /= 10; | |
| out[2] = '0' + (value % 10); | |
| value /= 10; | |
| out[1] = '0' + (value % 10); | |
| value /= 10; | |
| out[0] = '0' + value; | |
| return true; | |
| } | |
| bool WriteTwoDigit(uint8_t value, uint8_t out[2]) { | |
| if (value >= 100) { | |
| return false; | |
| } | |
| out[0] = '0' + (value / 10); | |
| out[1] = '0' + (value % 10); | |
| return true; | |
| } | |
| } // namespace | |
| bool EncodePosixTimeAsGeneralizedTime(int64_t posix_time, | |
| GeneralizedTime *generalized_time) { | |
| struct tm tmp_tm; | |
| if (!OPENSSL_posix_to_tm(posix_time, &tmp_tm)) { | |
| return false; | |
| } | |
| generalized_time->year = tmp_tm.tm_year + 1900; | |
| generalized_time->month = tmp_tm.tm_mon + 1; | |
| generalized_time->day = tmp_tm.tm_mday; | |
| generalized_time->hours = tmp_tm.tm_hour; | |
| generalized_time->minutes = tmp_tm.tm_min; | |
| generalized_time->seconds = tmp_tm.tm_sec; | |
| return true; | |
| } | |
| bool GeneralizedTimeToPosixTime(const der::GeneralizedTime &generalized, | |
| int64_t *result) { | |
| struct tm tmp_tm; | |
| tmp_tm.tm_year = generalized.year - 1900; | |
| tmp_tm.tm_mon = generalized.month - 1; | |
| tmp_tm.tm_mday = generalized.day; | |
| tmp_tm.tm_hour = generalized.hours; | |
| tmp_tm.tm_min = generalized.minutes; | |
| tmp_tm.tm_sec = generalized.seconds; | |
| // BoringSSL POSIX time, like POSIX itself, does not support leap seconds. | |
| // Collapse to previous second. | |
| if (tmp_tm.tm_sec == 60) { | |
| tmp_tm.tm_sec = 59; | |
| } | |
| return OPENSSL_tm_to_posix(&tmp_tm, result); | |
| } | |
| bool EncodeGeneralizedTime(const GeneralizedTime &time, | |
| uint8_t out[kGeneralizedTimeLength]) { | |
| if (!WriteFourDigit(time.year, out) || !WriteTwoDigit(time.month, out + 4) || | |
| !WriteTwoDigit(time.day, out + 6) || | |
| !WriteTwoDigit(time.hours, out + 8) || | |
| !WriteTwoDigit(time.minutes, out + 10) || | |
| !WriteTwoDigit(time.seconds, out + 12)) { | |
| return false; | |
| } | |
| out[14] = 'Z'; | |
| return true; | |
| } | |
| bool EncodeUTCTime(const GeneralizedTime &time, uint8_t out[kUTCTimeLength]) { | |
| if (!time.InUTCTimeRange()) { | |
| return false; | |
| } | |
| uint16_t year = time.year - 1900; | |
| if (year >= 100) { | |
| year -= 100; | |
| } | |
| if (!WriteTwoDigit(year, out) || !WriteTwoDigit(time.month, out + 2) || | |
| !WriteTwoDigit(time.day, out + 4) || | |
| !WriteTwoDigit(time.hours, out + 6) || | |
| !WriteTwoDigit(time.minutes, out + 8) || | |
| !WriteTwoDigit(time.seconds, out + 10)) { | |
| return false; | |
| } | |
| out[12] = 'Z'; | |
| return true; | |
| } | |
| bool EncodeUnsignedAlgorithmIdentifier(CBB *cbb) { | |
| // RFC 9925, Section 3.1: The AlgorithmIdentifier for id-alg-unsigned | |
| // (1.3.6.1.5.5.7.6.36), with the parameters field omitted. | |
| // clang-format off | |
| static const uint8_t kUnsignedAlgorithmIdentifier[] = { | |
| 0x30, 10, // SEQUENCE (10 bytes) | |
| 0x06, 8, OBJ_ENC_alg_unsigned, // OBJECT IDENTIFIER (8 bytes) | |
| }; | |
| // clang-format on | |
| return CBB_add_bytes(cbb, kUnsignedAlgorithmIdentifier, | |
| sizeof(kUnsignedAlgorithmIdentifier)); | |
| } | |
| bool EncodeUnsignedIssuerName(CBB *cbb) { | |
| // RFC 9925, Section 3.2: A Name with a single attribute of type | |
| // id-rdna-unsigned (1.3.6.1.5.5.7.25.1), whose value is an empty UTF8String. | |
| // clang-format off | |
| static const uint8_t kUnsignedIssuerName[] = { | |
| 0x30, 16, // SEQUENCE (16 bytes) | |
| 0x31, 14, // SET (14 bytes) | |
| 0x30, 12, // SEQUENCE (12 bytes) | |
| 0x06, 8, OBJ_ENC_rdna_unsigned, // OBJECT IDENTIFIER (8 bytes) | |
| 0x0c, 0, // UTF8String (0 bytes) | |
| }; | |
| // clang-format on | |
| return CBB_add_bytes(cbb, kUnsignedIssuerName, sizeof(kUnsignedIssuerName)); | |
| } | |
| bool EncodeExtension(CBB *cbb, Span<const uint8_t> oid, bool critical, | |
| Span<const uint8_t> value) { | |
| CBB extension; | |
| return CBB_add_asn1(cbb, &extension, CBS_ASN1_SEQUENCE) && | |
| CBB_add_asn1_element(&extension, CBS_ASN1_OBJECT, oid.data(), | |
| oid.size()) && | |
| (!critical || CBB_add_asn1_bool(&extension, 1)) && | |
| CBB_add_asn1_octet_string(&extension, value.data(), value.size()) && | |
| CBB_flush(cbb); | |
| } | |
| } // namespace der | |
| BSSL_NAMESPACE_END |